DefinitionTree {
    definitions: [
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 0,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 5,
                        value: "address",
                    },
                    templates: None,
                },
                equals: 13,
                type_definition: Tuple {
                    left_parenthesis: 15,
                    type_definitions: CommaSeparated {
                        inner: [
                            String(
                                Keyword {
                                    value: "string",
                                    position: 16,
                                },
                            ),
                            SignedInteger(
                                Default(
                                    Keyword {
                                        value: "int",
                                        position: 24,
                                    },
                                ),
                            ),
                        ],
                        commas: [
                            22,
                        ],
                    },
                    right_parenthesis: 27,
                },
                semicolon: 28,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 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,
                type_definition: Identifier(
                    TemplatedIdentifier {
                        name: Identifier {
                            position: 51,
                            value: "Closure",
                        },
                        templates: Some(
                            TypeTemplateGroupDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                less_than: 58,
                                members: CommaSeparated {
                                    inner: [
                                        Tuple {
                                            left_parenthesis: 59,
                                            type_definitions: CommaSeparated {
                                                inner: [
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 60,
                                                                value: "T",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: 61,
                                        },
                                        Identifier(
                                            TemplatedIdentifier {
                                                name: Identifier {
                                                    position: 64,
                                                    value: "U",
                                                },
                                                templates: None,
                                            },
                                        ),
                                    ],
                                    commas: [
                                        62,
                                    ],
                                },
                                greater_than: 65,
                            },
                        ),
                    },
                ),
                semicolon: 66,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 69,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 74,
                        value: "reducer",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 81,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 82,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 85,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    83,
                                ],
                            },
                            greater_than: 86,
                        },
                    ),
                },
                equals: 88,
                type_definition: Identifier(
                    TemplatedIdentifier {
                        name: Identifier {
                            position: 90,
                            value: "Closure",
                        },
                        templates: Some(
                            TypeTemplateGroupDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                less_than: 97,
                                members: CommaSeparated {
                                    inner: [
                                        Tuple {
                                            left_parenthesis: 98,
                                            type_definitions: CommaSeparated {
                                                inner: [
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 99,
                                                                value: "T",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 102,
                                                                value: "U",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                ],
                                                commas: [
                                                    100,
                                                ],
                                            },
                                            right_parenthesis: 103,
                                        },
                                        Identifier(
                                            TemplatedIdentifier {
                                                name: Identifier {
                                                    position: 106,
                                                    value: "U",
                                                },
                                                templates: None,
                                            },
                                        ),
                                    ],
                                    commas: [
                                        104,
                                    ],
                                },
                                greater_than: 107,
                            },
                        ),
                    },
                ),
                semicolon: 108,
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 111,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 116,
                        value: "filter",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 122,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 123,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 124,
                        },
                    ),
                },
                equals: 126,
                type_definition: Identifier(
                    TemplatedIdentifier {
                        name: Identifier {
                            position: 128,
                            value: "Closure",
                        },
                        templates: Some(
                            TypeTemplateGroupDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                less_than: 135,
                                members: CommaSeparated {
                                    inner: [
                                        Tuple {
                                            left_parenthesis: 136,
                                            type_definitions: CommaSeparated {
                                                inner: [
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 137,
                                                                value: "T",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: 138,
                                        },
                                        Boolean(
                                            Keyword {
                                                value: "bool",
                                                position: 141,
                                            },
                                        ),
                                    ],
                                    commas: [
                                        139,
                                    ],
                                },
                                greater_than: 145,
                            },
                        ),
                    },
                ),
                semicolon: 146,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 149,
                },
                name: Identifier {
                    position: 158,
                    value: "vec_filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 168,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 169,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 170,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 171,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    Keyword {
                                        value: "vec",
                                        position: 177,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 180,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 181,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 182,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 184,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 194,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 200,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 201,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 202,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 204,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            188,
                        ],
                    },
                    right_parenthesis: 212,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 213,
                    type_definition: Vec(
                        Keyword {
                            value: "vec",
                            position: 215,
                        },
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 218,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 219,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 220,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 222,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 228,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 236,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Keyword {
                                                    value: "vec",
                                                    position: 238,
                                                },
                                                left_bracket: 241,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 242,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 243,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 249,
                                },
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 257,
                                            name: "$vec",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 262,
                                    },
                                    value: Variable {
                                        position: 265,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 271,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 281,
                                                },
                                                conditions: CommaSeparated {
                                                    inner: [
                                                        FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 284,
                                                                        name: "$filter",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 291,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 292,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 297,
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 299,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Push {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 313,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 320,
                                                                                right_bracket: 321,
                                                                            },
                                                                        ),
                                                                        equals: 323,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 325,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 330,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 340,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 346,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: Keyword {
                                    value: "return",
                                    position: 353,
                                },
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 360,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 367,
                            },
                        ),
                    ],
                    right_brace: 369,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 372,
                },
                name: Identifier {
                    position: 381,
                    value: "vec_map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 388,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 389,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 392,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                390,
                            ],
                        },
                        greater_than: 393,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 394,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    Keyword {
                                        value: "vec",
                                        position: 400,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 403,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 404,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 405,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 407,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 417,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 423,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 424,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 427,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        425,
                                                    ],
                                                },
                                                greater_than: 428,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 430,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            411,
                        ],
                    },
                    right_parenthesis: 438,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 439,
                    type_definition: Tuple {
                        left_parenthesis: 441,
                        type_definitions: CommaSeparated {
                            inner: [
                                Vec(
                                    Keyword {
                                        value: "vec",
                                        position: 442,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 445,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 446,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 447,
                                    },
                                ),
                                Vec(
                                    Keyword {
                                        value: "vec",
                                        position: 450,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 453,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 454,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 455,
                                    },
                                ),
                            ],
                            commas: [
                                448,
                            ],
                        },
                        right_parenthesis: 456,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 458,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 464,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 472,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Keyword {
                                                    value: "vec",
                                                    position: 474,
                                                },
                                                left_bracket: 477,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 478,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 479,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 485,
                                },
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 493,
                                            name: "$vec",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 498,
                                    },
                                    value: Variable {
                                        position: 501,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 507,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Push {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 517,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 524,
                                                                right_bracket: 525,
                                                            },
                                                        ),
                                                        equals: 527,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 529,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 536,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 537,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 542,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 543,
                                            },
                                        ),
                                    ],
                                    right_brace: 549,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 556,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 557,
                                                        name: "$vec",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 563,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                561,
                                            ],
                                        },
                                        right_parenthesis: 570,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 572,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 575,
                },
                name: Identifier {
                    position: 584,
                    value: "dict_filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 595,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 596,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 599,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                597,
                            ],
                        },
                        greater_than: 600,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 601,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 607,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 611,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 612,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 615,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                613,
                                            ],
                                        },
                                        greater_than: 616,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 618,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 629,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 635,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 636,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 637,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 639,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            623,
                        ],
                    },
                    right_parenthesis: 647,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 648,
                    type_definition: Dict(
                        Keyword {
                            value: "dict",
                            position: 650,
                        },
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 654,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 655,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 658,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    656,
                                ],
                            },
                            greater_than: 659,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 661,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 667,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 675,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Keyword {
                                                    value: "dict",
                                                    position: 677,
                                                },
                                                left_bracket: 681,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 682,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 683,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 689,
                                },
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 697,
                                            name: "$dict",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 703,
                                    },
                                    key: Variable {
                                        position: 706,
                                        name: "$key",
                                    },
                                    double_arrow: 711,
                                    value: Variable {
                                        position: 714,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 720,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 730,
                                                },
                                                conditions: CommaSeparated {
                                                    inner: [
                                                        FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 733,
                                                                        name: "$filter",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 740,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 741,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 746,
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 748,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 762,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 769,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 770,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 774,
                                                                            },
                                                                        ),
                                                                        equals: 776,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 778,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 783,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 793,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 799,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: Keyword {
                                    value: "return",
                                    position: 806,
                                },
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 813,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 820,
                            },
                        ),
                    ],
                    right_brace: 822,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 825,
                },
                name: Identifier {
                    position: 834,
                    value: "dict_map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 842,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 843,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 846,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 849,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                844,
                                847,
                            ],
                        },
                        greater_than: 850,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 851,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 857,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 861,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 862,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 865,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                863,
                                            ],
                                        },
                                        greater_than: 866,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 868,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 879,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 885,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 886,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 889,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        887,
                                                    ],
                                                },
                                                greater_than: 890,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 892,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            873,
                        ],
                    },
                    right_parenthesis: 900,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 901,
                    type_definition: Tuple {
                        left_parenthesis: 903,
                        type_definitions: CommaSeparated {
                            inner: [
                                Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 904,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 908,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 909,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 912,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                910,
                                            ],
                                        },
                                        greater_than: 913,
                                    },
                                ),
                                Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 916,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 920,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 921,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 924,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                922,
                                            ],
                                        },
                                        greater_than: 925,
                                    },
                                ),
                            ],
                            commas: [
                                914,
                            ],
                        },
                        right_parenthesis: 926,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 928,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 934,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 942,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Keyword {
                                                    value: "dict",
                                                    position: 944,
                                                },
                                                left_bracket: 948,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 949,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 950,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 956,
                                },
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 964,
                                            name: "$dict",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 970,
                                    },
                                    key: Variable {
                                        position: 973,
                                        name: "$key",
                                    },
                                    double_arrow: 978,
                                    value: Variable {
                                        position: 981,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 987,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Access {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 997,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 1004,
                                                                index: Variable(
                                                                    Variable {
                                                                        position: 1005,
                                                                        name: "$key",
                                                                    },
                                                                ),
                                                                right_bracket: 1009,
                                                            },
                                                        ),
                                                        equals: 1011,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 1013,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 1020,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 1021,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 1026,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 1027,
                                            },
                                        ),
                                    ],
                                    right_brace: 1033,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 1040,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 1041,
                                                        name: "$dict",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 1048,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1046,
                                            ],
                                        },
                                        right_parenthesis: 1055,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 1057,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 1060,
                },
                name: Identifier {
                    position: 1069,
                    value: "iterable_map_to_dict",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 1089,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1090,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1093,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1096,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                1091,
                                1094,
                            ],
                        },
                        greater_than: 1097,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1098,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    Keyword {
                                        value: "iterable",
                                        position: 1104,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1112,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1113,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1116,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1114,
                                            ],
                                        },
                                        greater_than: 1117,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1119,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 1134,
                                            value: "mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 1140,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1141,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1144,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        1142,
                                                    ],
                                                },
                                                greater_than: 1145,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1147,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            1128,
                        ],
                    },
                    right_parenthesis: 1155,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1156,
                    type_definition: Tuple {
                        left_parenthesis: 1158,
                        type_definitions: CommaSeparated {
                            inner: [
                                Iterable(
                                    Keyword {
                                        value: "iterable",
                                        position: 1159,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1167,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1168,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1171,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1169,
                                            ],
                                        },
                                        greater_than: 1172,
                                    },
                                ),
                                Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 1175,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1179,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1180,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1183,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1181,
                                            ],
                                        },
                                        greater_than: 1184,
                                    },
                                ),
                            ],
                            commas: [
                                1173,
                                1185,
                            ],
                        },
                        right_parenthesis: 1186,
                    },
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1188,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1194,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 1202,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Keyword {
                                                    value: "dict",
                                                    position: 1204,
                                                },
                                                left_bracket: 1208,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 1209,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1210,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 1216,
                                },
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 1224,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 1234,
                                    },
                                    key: Variable {
                                        position: 1237,
                                        name: "$key",
                                    },
                                    double_arrow: 1242,
                                    value: Variable {
                                        position: 1245,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 1251,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Access {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 1261,
                                                                        name: "$result",
                                                                    },
                                                                ),
                                                                left_bracket: 1268,
                                                                index: Variable(
                                                                    Variable {
                                                                        position: 1269,
                                                                        name: "$key",
                                                                    },
                                                                ),
                                                                right_bracket: 1273,
                                                            },
                                                        ),
                                                        equals: 1275,
                                                        right: FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 1277,
                                                                        name: "$mapper",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 1284,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 1285,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 1290,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 1291,
                                            },
                                        ),
                                    ],
                                    right_brace: 1297,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Implicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Tuple(
                                    TupleExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 1304,
                                        elements: CommaSeparated {
                                            inner: [
                                                Variable(
                                                    Variable {
                                                        position: 1305,
                                                        name: "$iterable",
                                                    },
                                                ),
                                                Variable(
                                                    Variable {
                                                        position: 1316,
                                                        name: "$result",
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1314,
                                            ],
                                        },
                                        right_parenthesis: 1323,
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 1325,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 1328,
                },
                name: Identifier {
                    position: 1337,
                    value: "iterable_filter_to_dict",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 1360,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1361,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1364,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                1362,
                            ],
                        },
                        greater_than: 1365,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1366,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    Keyword {
                                        value: "iterable",
                                        position: 1372,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1380,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1381,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1384,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1382,
                                            ],
                                        },
                                        greater_than: 1385,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1387,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 1402,
                                            value: "filter",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 1408,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 1409,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 1410,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1412,
                                    name: "$filter",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            1396,
                        ],
                    },
                    right_parenthesis: 1420,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1421,
                    type_definition: Dict(
                        Keyword {
                            value: "dict",
                            position: 1423,
                        },
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 1427,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1428,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1431,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    1429,
                                ],
                            },
                            greater_than: 1432,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1434,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1440,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 1448,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Keyword {
                                                    value: "dict",
                                                    position: 1450,
                                                },
                                                left_bracket: 1454,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 1455,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1456,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 1462,
                                },
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 1470,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 1480,
                                    },
                                    key: Variable {
                                        position: 1483,
                                        name: "$key",
                                    },
                                    double_arrow: 1488,
                                    value: Variable {
                                        position: 1491,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 1497,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 1507,
                                                },
                                                conditions: CommaSeparated {
                                                    inner: [
                                                        FunctionOperation(
                                                            Call {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                function: Variable(
                                                                    Variable {
                                                                        position: 1510,
                                                                        name: "$filter",
                                                                    },
                                                                ),
                                                                generics: None,
                                                                arguments: ArgumentListExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    left_parenthesis: 1517,
                                                                    arguments: CommaSeparated {
                                                                        inner: [
                                                                            Value {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                value: Variable(
                                                                                    Variable {
                                                                                        position: 1518,
                                                                                        name: "$item",
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                    right_parenthesis: 1523,
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 1525,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 1539,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 1546,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 1547,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 1551,
                                                                            },
                                                                        ),
                                                                        equals: 1553,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 1555,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 1560,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 1570,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 1576,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: Keyword {
                                    value: "return",
                                    position: 1583,
                                },
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 1590,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 1597,
                            },
                        ),
                    ],
                    right_brace: 1599,
                },
            },
        ),
    ],
    eof: 1601,
}