valkyrie-parser 0.2.5

NamespaceDeclaration {
    kind: Standalone,
    path: std∷create∷test,
}
Union {
    annotations: Annotation {
        attributes: [
            AttributeTerm {
                kind: Normal,
                path: tag,
                variant: [],
                arguments: [],
                domain: None,
                span: 101..105,
            },
        ],
    },
    name: Union1,
    body: [],
    span: 100..120,
}
Union {
    annotations: Annotation {
        attributes: [
            AttributeTerm {
                kind: Normal,
                path: tag,
                variant: [],
                arguments: [
                    ArgumentTerm {
                        key: Nothing,
                        value: Tag1,
                    },
                ],
                domain: None,
                span: 151..161,
            },
        ],
    },
    name: Union2,
    body: [
        Variant {
            name: Variant1,
        },
        Variant {
            name: Variant2,
        },
        Variant {
            name: Variant3,
            body: [
                Field {
                    name: field1,
                },
            ],
        },
    ],
    span: 150..242,
}
Union {
    annotations: Annotation {
        attributes: [
            AttributeTerm {
                kind: Normal,
                path: tag,
                variant: [],
                arguments: [
                    ArgumentTerm {
                        key: Nothing,
                        value: UnaryNode {
                            prefix: &,
                            base: Tag1,
                        },
                    },
                ],
                domain: None,
                span: 276..287,
            },
        ],
    },
    name: Union3,
    body: [
        Variant {
            name: Variant1,
        },
        Variant {
            name: Variant2,
        },
        Variant {
            name: Variant3,
            body: [
                Field {
                    name: field1,
                },
                Field {
                    name: field2,
                },
                Field {
                    name: field3,
                },
            ],
        },
    ],
    span: 275..402,
}
Union {
    name: Union4,
    body: [
        Variant {
            name: Variant1,
            body: [
                Field {
                    annotations: Annotation {
                        modifiers: [
                            public,
                            static,
                        ],
                    },
                    name: field_a,
                },
                Method {
                    annotations: Annotation {
                        modifiers: [
                            mut,
                            field_b,
                        ],
                    },
                    name: display,
                    parameters: [
                        Parameter {
                            key: "self",
                        },
                    ],
                    body: [],
                    span: 473..519,
                },
            ],
        },
        Method {
            name: display,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            span: 531..544,
        },
        Method {
            name: method,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            body: [
                MatchStatement {
                    kind: Typing,
                    bind: None,
                    main: self,
                    patterns: [],
                    span: 572..595,
                },
            ],
            span: 550..601,
        },
    ],
    span: 404..603,
}
Union {
    name: A,
    implements: InfixNode {
        infix: +,
        lhs: A,
        rhs: B,
    },
    body: [
        Variant {
            name: A,
        },
        Variant {
            name: Bb,
        },
        Variant {
            name: Ccc,
        },
    ],
    span: 630..683,
}
Union {
    name: Option,
    body: [
        Variant {
            name: Some,
            body: [
                Field {
                    name: value,
                    type: T,
                },
            ],
        },
        Variant {
            name: None,
        },
    ],
    span: 704..820,
}
Union {
    name: Result,
    body: [
        Variant {
            name: Success,
            body: [
                Field {
                    name: value,
                    type: V,
                },
            ],
        },
        Variant {
            name: Failure,
            body: [
                Field {
                    name: error,
                    type: E,
                },
            ],
        },
    ],
    span: 822..939,
}
Union {
    name: Validation,
    body: [
        Variant {
            name: Fine,
            body: [
                Field {
                    name: value,
                    type: T,
                },
                Field {
                    name: errors,
                    type: GenericCallNode {
                        monadic: false,
                        base: List,
                        term: [
                            ArgumentTerm {
                                key: Nothing,
                                value: E,
                            },
                        ],
                        span: 1019..1026,
                    },
                },
            ],
        },
        Variant {
            name: Fail,
            body: [
                Field {
                    name: fatal,
                    type: E,
                },
                Field {
                    name: errors,
                    type: GenericCallNode {
                        monadic: false,
                        base: List,
                        term: [
                            ArgumentTerm {
                                key: Nothing,
                                value: E,
                            },
                        ],
                        span: 1083..1090,
                    },
                },
            ],
        },
        Method {
            name: as_result,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            returns: GenericCallNode {
                monadic: false,
                base: Result,
                term: [
                    ArgumentTerm {
                        key: Nothing,
                        value: T,
                    },
                    ArgumentTerm {
                        key: Nothing,
                        value: E,
                    },
                ],
                span: 1125..1135,
            },
            body: [
                MatchStatement {
                    kind: Typing,
                    bind: None,
                    main: self,
                    patterns: [
                        PatternBranch {
                            condition: PatternCaseNode {
                                pattern: TuplePatternNode {
                                    bind: None,
                                    name: None,
                                    terms: [
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("value", 1183..1188),
                                        },
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("", 0..0),
                                        },
                                    ],
                                    span: 0..0,
                                },
                                guard: None,
                                span: 1171..1240,
                            },
                            continuation: [
                                ApplyCallNode {
                                    monadic: false,
                                    caller: Success,
                                    arguments: [
                                        ArgumentTerm {
                                            key: Nothing,
                                            value: value,
                                        },
                                    ],
                                    body: None,
                                    span: 1220..1227,
                                },
                            ],
                            span: 1171..1240,
                        },
                        PatternBranch {
                            condition: PatternCaseNode {
                                pattern: TuplePatternNode {
                                    bind: None,
                                    name: None,
                                    terms: [
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("fatal", 1252..1257),
                                        },
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("", 0..0),
                                        },
                                    ],
                                    span: 0..0,
                                },
                                guard: None,
                                span: 1240..1305,
                            },
                            continuation: [
                                ApplyCallNode {
                                    monadic: false,
                                    caller: Failure,
                                    arguments: [
                                        ArgumentTerm {
                                            key: Nothing,
                                            value: fatal,
                                        },
                                    ],
                                    body: None,
                                    span: 1289..1296,
                                },
                            ],
                            span: 1240..1305,
                        },
                    ],
                    span: 1146..1306,
                },
            ],
            span: 1102..1312,
        },
        Method {
            name: as_option,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            returns: GenericCallNode {
                monadic: false,
                base: Option,
                term: [
                    ArgumentTerm {
                        key: Nothing,
                        value: T,
                    },
                ],
                span: 1340..1347,
            },
            body: [
                MatchStatement {
                    kind: Typing,
                    bind: None,
                    main: self,
                    patterns: [
                        PatternBranch {
                            condition: PatternCaseNode {
                                pattern: TuplePatternNode {
                                    bind: None,
                                    name: None,
                                    terms: [
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("value", 1395..1400),
                                        },
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("", 0..0),
                                        },
                                    ],
                                    span: 0..0,
                                },
                                guard: None,
                                span: 1383..1449,
                            },
                            continuation: [
                                ApplyCallNode {
                                    monadic: false,
                                    caller: Some,
                                    arguments: [
                                        ArgumentTerm {
                                            key: Nothing,
                                            value: value,
                                        },
                                    ],
                                    body: None,
                                    span: 1429..1436,
                                },
                            ],
                            span: 1383..1449,
                        },
                        PatternBranch {
                            condition: PatternCaseNode {
                                pattern: TuplePatternNode {
                                    bind: None,
                                    name: None,
                                    terms: [
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("fatal", 1461..1466),
                                        },
                                        IdentifierPattern {
                                            modifiers: [],
                                            identifier: Identifier("", 0..0),
                                        },
                                    ],
                                    span: 0..0,
                                },
                                guard: None,
                                span: 1449..1504,
                            },
                            continuation: [
                                None,
                            ],
                            span: 1449..1504,
                        },
                    ],
                    span: 1358..1505,
                },
            ],
            span: 1317..1511,
        },
    ],
    span: 941..1513,
}
ExtendsStatement {
    implements: None,
    body: [
        Method {
            name: is_fine,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            returns: bool,
            body: [
                ProceduralNode {
                    kind: Normal,
                    path: matches,
                    arguments: [],
                    domain: None,
                    span: 1593..1625,
                },
            ],
            span: 1563..1626,
        },
        Method {
            name: is_fail,
            parameters: [
                Parameter {
                    key: "self",
                },
            ],
            returns: bool,
            body: [
                ProceduralNode {
                    kind: Normal,
                    path: matches,
                    arguments: [],
                    domain: None,
                    span: 1661..1693,
                },
            ],
            span: 1631..1694,
        },
    ],
}