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