DefinitionTree {
    definitions: [
        TypeAlias(
            TypeAliasDefinition {
                type: 0,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 5,
                        value: "address",
                    },
                    templates: None,
                },
                equals: 13,
                data_type: Tuple {
                    left_parenthesis: 15,
                    type_definitions: CommaSeparated {
                        inner: [
                            String(
                                16,
                            ),
                            Integer(
                                24,
                            ),
                        ],
                        commas: [
                            22,
                        ],
                    },
                    right_parenthesis: 27,
                },
                semicolon: 28,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: 31,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 36,
                        value: "mapper",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 42,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 43,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 46,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    44,
                                ],
                            },
                            greater_than: 47,
                        },
                    ),
                },
                equals: 49,
                data_type: Function {
                    outer_left_parenthesis: 51,
                    fn: 52,
                    left_parenthesis: 54,
                    parameter_type_definitions: CommaSeparated {
                        inner: [
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 55,
                                        value: "T",
                                    },
                                    templates: None,
                                },
                            ),
                        ],
                        commas: [],
                    },
                    right_parenthesis: 56,
                    colon: 57,
                    return_type_definition: Identifier(
                        TemplatedIdentifier {
                            name: Identifier {
                                position: 59,
                                value: "U",
                            },
                            templates: None,
                        },
                    ),
                    outer_right_parenthesis: 60,
                },
                semicolon: 61,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: 64,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 69,
                        value: "reducer",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 76,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 77,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 80,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    78,
                                ],
                            },
                            greater_than: 81,
                        },
                    ),
                },
                equals: 83,
                data_type: Function {
                    outer_left_parenthesis: 85,
                    fn: 86,
                    left_parenthesis: 88,
                    parameter_type_definitions: CommaSeparated {
                        inner: [
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 89,
                                        value: "T",
                                    },
                                    templates: None,
                                },
                            ),
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 92,
                                        value: "U",
                                    },
                                    templates: None,
                                },
                            ),
                        ],
                        commas: [
                            90,
                        ],
                    },
                    right_parenthesis: 93,
                    colon: 94,
                    return_type_definition: Identifier(
                        TemplatedIdentifier {
                            name: Identifier {
                                position: 96,
                                value: "U",
                            },
                            templates: None,
                        },
                    ),
                    outer_right_parenthesis: 97,
                },
                semicolon: 98,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: 101,
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 106,
                        value: "filter",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 112,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 113,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 114,
                        },
                    ),
                },
                equals: 116,
                data_type: Function {
                    outer_left_parenthesis: 118,
                    fn: 119,
                    left_parenthesis: 121,
                    parameter_type_definitions: CommaSeparated {
                        inner: [
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 122,
                                        value: "T",
                                    },
                                    templates: None,
                                },
                            ),
                        ],
                        commas: [],
                    },
                    right_parenthesis: 123,
                    colon: 124,
                    return_type_definition: Boolean(
                        126,
                    ),
                    outer_right_parenthesis: 130,
                },
                semicolon: 131,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 134,
                name: Identifier {
                    position: 143,
                    value: "vec_filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 153,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 154,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 155,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 156,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    162,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 165,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 166,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 167,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 169,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 179,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 185,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 186,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 187,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 189,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            173,
                        ],
                    },
                    right_parenthesis: 197,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 198,
                    type_definition: Vec(
                        200,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 203,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 204,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 205,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 207,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 213,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 221,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 223,
                                                left_bracket: 226,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 227,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 228,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 234,
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 242,
                                            name: "$vec",
                                        },
                                    ),
                                    as: 247,
                                    value: Variable {
                                        position: 250,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 256,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: 266,
                                                condition: FunctionOperation(
                                                    Call {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        function: Variable(
                                                            Variable {
                                                                position: 269,
                                                                name: "$filter",
                                                            },
                                                        ),
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 276,
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Positional {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        ellipsis: None,
                                                                        value: Variable(
                                                                            Variable {
                                                                                position: 277,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: 282,
                                                        },
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 284,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Push {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 298,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 305,
                                                                                right_bracket: 306,
                                                                            },
                                                                        ),
                                                                        equals: 308,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 310,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 315,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 325,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 331,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 338,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 345,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 352,
                            },
                        ),
                    ],
                    right_brace: 354,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 357,
                name: Identifier {
                    position: 366,
                    value: "vec_map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 373,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 374,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 377,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                375,
                            ],
                        },
                        greater_than: 378,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 379,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    385,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 388,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 389,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 390,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 392,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 402,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 408,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 409,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 412,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        410,
                                                    ],
                                                },
                                                greater_than: 413,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 415,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            396,
                        ],
                    },
                    right_parenthesis: 423,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 424,
                    type_definition: Tuple {
                        left_parenthesis: 426,
                        type_definitions: CommaSeparated {
                            inner: [
                                Vec(
                                    427,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 430,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 431,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 432,
                                    },
                                ),
                                Vec(
                                    435,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 438,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 439,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 440,
                                    },
                                ),
                            ],
                            commas: [
                                433,
                            ],
                        },
                        right_parenthesis: 441,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 443,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 449,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 457,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 459,
                                                left_bracket: 462,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 463,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 464,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 470,
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 478,
                                            name: "$vec",
                                        },
                                    ),
                                    as: 483,
                                    value: Variable {
                                        position: 486,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 492,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Push {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 502,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 509,
                                                                right_bracket: 510,
                                                            },
                                                        ),
                                                        equals: 512,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 514,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 521,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Positional {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                ellipsis: None,
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 522,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 527,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 528,
                                            },
                                        ),
                                    ],
                                    right_brace: 534,
                                },
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 541,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 542,
                                                        name: "$vec",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 548,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                546,
                                            ],
                                        },
                                        right_parenthesis: 555,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 557,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 560,
                name: Identifier {
                    position: 569,
                    value: "dict_filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 580,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 581,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 584,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                582,
                            ],
                        },
                        greater_than: 585,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 586,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    592,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 596,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 597,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 600,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                598,
                                            ],
                                        },
                                        greater_than: 601,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 603,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 614,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 620,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 621,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 622,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 624,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            608,
                        ],
                    },
                    right_parenthesis: 632,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 633,
                    type_definition: Dict(
                        635,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 639,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 640,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 643,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    641,
                                ],
                            },
                            greater_than: 644,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 646,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 652,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 660,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 662,
                                                left_bracket: 666,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 667,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 668,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 674,
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 682,
                                            name: "$dict",
                                        },
                                    ),
                                    as: 688,
                                    key: Variable {
                                        position: 691,
                                        name: "$key",
                                    },
                                    double_arrow: 696,
                                    value: Variable {
                                        position: 699,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 705,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: 715,
                                                condition: FunctionOperation(
                                                    Call {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        function: Variable(
                                                            Variable {
                                                                position: 718,
                                                                name: "$filter",
                                                            },
                                                        ),
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 725,
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Positional {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        ellipsis: None,
                                                                        value: Variable(
                                                                            Variable {
                                                                                position: 726,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: 731,
                                                        },
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 733,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 747,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 754,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 755,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 759,
                                                                            },
                                                                        ),
                                                                        equals: 761,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 763,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 768,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 778,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 784,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 791,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 798,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 805,
                            },
                        ),
                    ],
                    right_brace: 807,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 810,
                name: Identifier {
                    position: 819,
                    value: "dict_map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 827,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 828,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 831,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 834,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                829,
                                832,
                            ],
                        },
                        greater_than: 835,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 836,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    842,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 846,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 847,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 850,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                848,
                                            ],
                                        },
                                        greater_than: 851,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 853,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 864,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 870,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 871,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 874,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        872,
                                                    ],
                                                },
                                                greater_than: 875,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 877,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            858,
                        ],
                    },
                    right_parenthesis: 885,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 886,
                    type_definition: Tuple {
                        left_parenthesis: 888,
                        type_definitions: CommaSeparated {
                            inner: [
                                Dict(
                                    889,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 893,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 894,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 897,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                895,
                                            ],
                                        },
                                        greater_than: 898,
                                    },
                                ),
                                Dict(
                                    901,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 905,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 906,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 909,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                907,
                                            ],
                                        },
                                        greater_than: 910,
                                    },
                                ),
                            ],
                            commas: [
                                899,
                            ],
                        },
                        right_parenthesis: 911,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 913,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 919,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 927,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 929,
                                                left_bracket: 933,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 934,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 935,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 941,
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 949,
                                            name: "$dict",
                                        },
                                    ),
                                    as: 955,
                                    key: Variable {
                                        position: 958,
                                        name: "$key",
                                    },
                                    double_arrow: 963,
                                    value: Variable {
                                        position: 966,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 972,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Access {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 982,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 989,
                                                                index: Variable(
                                                                    Variable {
                                                                        position: 990,
                                                                        name: "$key",
                                                                    },
                                                                ),
                                                                right_bracket: 994,
                                                            },
                                                        ),
                                                        equals: 996,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 998,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 1005,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Positional {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                ellipsis: None,
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 1006,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 1011,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 1012,
                                            },
                                        ),
                                    ],
                                    right_brace: 1018,
                                },
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 1025,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 1026,
                                                        name: "$dict",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 1033,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1031,
                                            ],
                                        },
                                        right_parenthesis: 1040,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 1042,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 1045,
                name: Identifier {
                    position: 1054,
                    value: "iterable_map_to_dict",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 1074,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1075,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1078,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1081,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                1076,
                                1079,
                            ],
                        },
                        greater_than: 1082,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1083,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    1089,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1097,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1098,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1101,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1099,
                                            ],
                                        },
                                        greater_than: 1102,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1104,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 1119,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 1125,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1126,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1129,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        1127,
                                                    ],
                                                },
                                                greater_than: 1130,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1132,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            1113,
                        ],
                    },
                    right_parenthesis: 1140,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1141,
                    type_definition: Tuple {
                        left_parenthesis: 1143,
                        type_definitions: CommaSeparated {
                            inner: [
                                Iterable(
                                    1144,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1152,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1153,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1156,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1154,
                                            ],
                                        },
                                        greater_than: 1157,
                                    },
                                ),
                                Dict(
                                    1160,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1164,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1165,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1168,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1166,
                                            ],
                                        },
                                        greater_than: 1169,
                                    },
                                ),
                            ],
                            commas: [
                                1158,
                                1170,
                            ],
                        },
                        right_parenthesis: 1171,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1173,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1179,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 1187,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 1189,
                                                left_bracket: 1193,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 1194,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1195,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 1201,
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 1209,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: 1219,
                                    key: Variable {
                                        position: 1222,
                                        name: "$key",
                                    },
                                    double_arrow: 1227,
                                    value: Variable {
                                        position: 1230,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 1236,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Access {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 1246,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 1253,
                                                                index: Variable(
                                                                    Variable {
                                                                        position: 1254,
                                                                        name: "$key",
                                                                    },
                                                                ),
                                                                right_bracket: 1258,
                                                            },
                                                        ),
                                                        equals: 1260,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 1262,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 1269,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Positional {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                ellipsis: None,
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 1270,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 1275,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 1276,
                                            },
                                        ),
                                    ],
                                    right_brace: 1282,
                                },
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 1289,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 1290,
                                                        name: "$iterable",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 1301,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1299,
                                            ],
                                        },
                                        right_parenthesis: 1308,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 1310,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 1313,
                name: Identifier {
                    position: 1322,
                    value: "iterable_filter_to_dict",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 1345,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1346,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1349,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                1347,
                            ],
                        },
                        greater_than: 1350,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1351,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    1357,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1365,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1366,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1369,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1367,
                                            ],
                                        },
                                        greater_than: 1370,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1372,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 1387,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 1393,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1394,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 1395,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1397,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            1381,
                        ],
                    },
                    right_parenthesis: 1405,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1406,
                    type_definition: Dict(
                        1408,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 1412,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1413,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1416,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    1414,
                                ],
                            },
                            greater_than: 1417,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1419,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1425,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 1433,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 1435,
                                                left_bracket: 1439,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 1440,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1441,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 1447,
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 1455,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: 1465,
                                    key: Variable {
                                        position: 1468,
                                        name: "$key",
                                    },
                                    double_arrow: 1473,
                                    value: Variable {
                                        position: 1476,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 1482,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: 1492,
                                                condition: FunctionOperation(
                                                    Call {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        function: Variable(
                                                            Variable {
                                                                position: 1495,
                                                                name: "$filter",
                                                            },
                                                        ),
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 1502,
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Positional {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        ellipsis: None,
                                                                        value: Variable(
                                                                            Variable {
                                                                                position: 1503,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: 1508,
                                                        },
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 1510,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 1524,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 1531,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 1532,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 1536,
                                                                            },
                                                                        ),
                                                                        equals: 1538,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 1540,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 1545,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 1555,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 1561,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 1568,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 1575,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 1582,
                            },
                        ),
                    ],
                    right_brace: 1584,
                },
            },
        ),
    ],
    eof: 1586,
}