valkyrie-parser 0.2.5

namespace std.create.test;

/// automatically generate tag type
/// `hidden enumerate Union1Tag {}`
#tag
union Union1 {}

/// create a new tag `Tag1`
#tag(Tag1)
union Union2 {
    Variant1
    Variant2 {}
    Variant3 {
        field1
    }
}

/// share an exists tag `Tag1`
#tag(&Tag1)
union Union3 {
    Variant1,
    Variant2 {}
    Variant3 {
        field1,
        field2;
        field3
    };
}

union Union4 {
    Variant1 {
        public static field_a,
        mut field_b
        display(self) {

        }
    }

    display(self);
    method(self){
        match self {

        }
    }
}


/// inherit `BaseUnion`
union A(BaseUnion): A + B {
    A,
    Bb,
    Ccc,
}


/// generic union
union Option⟨T⟩ {
    // Some value of type `T`.
    Some {
        value: T
    },
    // No value.
    None,
}

generic T, E { }
union Result⟨V, E⟩ {
    Success {
        value: V
    }
    Failure {
        error: E
    }
}

union Validation⟨T, E⟩ {
    Fine {
        value: T,
        errors: List⟨E⟩
    },
    Fail {
        fatal: E,
        errors: List⟨E⟩
    },
    as_result(self): Result⟨T, E⟩ {
        match self {
            case Fine { value, ... }:
                Success(value)
            case Fail { fatal, ... }:
                Failure(fatal)
        }
    }
    as_option(self): Option⟨T⟩ {
        match self {
            case Fine { value, ... }:
                Some(value)
            case Fail { fatal, ... }:
                None
        }
    }
}

generic T, E { }
extends Validation<T, E> {
    is_fine(self): bool {
        @matches(self, Fine(_, []))
    }
    is_fail(self): bool {
        @matches(self, Fail(_, []))
    }
}