1 
use super::{Domain, DomainOpError, DomainPtr, GroundDomain, UnresolvedDomain};
2 
use crate::ast::Moo;
3 

            

        

            

                4
            

            

                
            

            

                
impl From<GroundDomain> for Domain {

            

        

            

                5
            

            

                
            

            

                
    fn from(gd: GroundDomain) -> Self {

            

        

            

                6
            

            

                
            

            

                
        Domain::Ground(Moo::new(gd))

            

        

            

                7
            

            

                
            

            

                
    }

            

        

            

                8
            

            

                
            

            

                
}

            

        

            

                9
            

            

                
            

            

                

            

        

            

                10
            

            

                
            

            

                
impl From<UnresolvedDomain> for Domain {

            

        

            

                11
            

            

                
            

            

                
    fn from(ud: UnresolvedDomain) -> Self {

            

        

            

                12
            

            

                
            

            

                
        Domain::Unresolved(Moo::new(ud))

            

        

            

                13
            

            

                
            

            

                
    }

            

        

            

                14
            

            

                
            

            

                
}

            

        

            

                15
            

            

                
            

            

                

            

        

            

                16
            

            

                
            

            

                
impl TryFrom<Domain> for Moo<GroundDomain> {

            

        

            

                17
            

            

                
            

            

                
    type Error = DomainOpError;

            

        

            

                18
            

            

                
            

            

                

            

        

            

                19
            

            

                
            

            

                
    fn try_from(value: Domain) -> Result<Self, Self::Error> {

            

        

            

                20
            

            

                
            

            

                
        match value {

            

        

            

                21
            

            

                
            

            

                
            Domain::Ground(gd) => Ok(gd),

            

        

            

                22
            

            

                
            

            

                
            Domain::Unresolved(_) => Err(DomainOpError::NotGround),

            

        

            

                23
            

            

                
            

            

                
        }

            

        

            

                24
            

            

                
            

            

                
    }

            

        

            

                25
            

            

                
            

            

                
}

            

        

            

                26
            

            

                
            

            

                

            

        

            

                27
            

            

                
            

            

                
impl TryFrom<Domain> for GroundDomain {

            

        

            

                28
            

            

                
            

            

                
    type Error = DomainOpError;

            

        

            

                29
            

            

                
            

            

                

            

        

            

                30
            

            

                
            

            

                
    fn try_from(value: Domain) -> Result<Self, Self::Error> {

            

        

            

                31
            

            

                
            

            

                
        Ok(Moo::unwrap_or_clone(value.try_into()?))

            

        

            

                32
            

            

                
            

            

                
    }

            

        

            

                33
            

            

                
            

            

                
}

            

        

            

                34
            

            

                
            

            

                

            

        

            

                35
            

            

                
            

            

                
impl From<Moo<GroundDomain>> for DomainPtr {

            

        

            

                36
            

            

                2572761
            

            

                
    fn from(value: Moo<GroundDomain>) -> Self {

            

        

            

                37
            

            

                2572761
            

            

                
        Moo::new(Domain::Ground(value))

            

        

            

                38
            

            

                2572761
            

            

                
    }

            

        

            

                39
            

            

                
            

            

                
}

            

        

            

                40
            

            

                
            

            

                

            

        

            

                41
            

            

                
            

            

                
impl From<&Moo<GroundDomain>> for DomainPtr {

            

        

            

                42
            

            

                
            

            

                
    fn from(value: &Moo<GroundDomain>) -> Self {

            

        

            

                43
            

            

                
            

            

                
        Moo::new(Domain::Ground(value.clone()))

            

        

            

                44
            

            

                
            

            

                
    }

            

        

            

                45
            

            

                
            

            

                
}

            

        

            

                46
            

            

                
            

            

                

            

        

            

                47
            

            

                
            

            

                
impl TryFrom<DomainPtr> for Moo<GroundDomain> {

            

        

            

                48
            

            

                
            

            

                
    type Error = DomainOpError;

            

        

            

                49
            

            

                
            

            

                

            

        

            

                50
            

            

                803
            

            

                
    fn try_from(value: DomainPtr) -> Result<Self, Self::Error> {

            

        

            

                51
            

            

                803
            

            

                
        match value.as_ref() {

            

        

            

                52
            

            

                723
            

            

                
            Domain::Ground(gd) => Ok(gd.clone()),

            

        

            

                53
            

            

                80
            

            

                
            Domain::Unresolved(_) => Err(DomainOpError::NotGround),

            

        

            

                54
            

            

                
            

            

                
        }

            

        

            

                55
            

            

                803
            

            

                
    }

            

        

            

                56
            

            

                
            

            

                
}

            

        

            

                57
            

            

                
            

            

                

            

        

            

                58
            

            

                
            

            

                
impl TryFrom<DomainPtr> for GroundDomain {

            

        

            

                59
            

            

                
            

            

                
    type Error = DomainOpError;

            

        

            

                60
            

            

                
            

            

                

            

        

            

                61
            

            

                
            

            

                
    fn try_from(value: DomainPtr) -> Result<Self, Self::Error> {

            

        

            

                62
            

            

                
            

            

                
        Ok(Moo::unwrap_or_clone(value.try_into()?))

            

        

            

                63
            

            

                
            

            

                
    }

            

        

            

                64
            

            

                
            

            

                
}

            

        

            

                65
            

            

                
            

            

                

            

        

            

                66
            

            

                
            

            

                
impl From<Moo<UnresolvedDomain>> for DomainPtr {

            

        

            

                67
            

            

                
            

            

                
    fn from(value: Moo<UnresolvedDomain>) -> Self {

            

        

            

                68
            

            

                
            

            

                
        Moo::new(Domain::Unresolved(value))

            

        

            

                69
            

            

                
            

            

                
    }

            

        

            

                70
            

            

                
            

            

                
}

            

        

            

                71
            

            

                
            

            

                

            

        

            

                72
            

            

                
            

            

                
impl From<&Moo<UnresolvedDomain>> for DomainPtr {

            

        

            

                73
            

            

                
            

            

                
    fn from(value: &Moo<UnresolvedDomain>) -> Self {

            

        

            

                74
            

            

                
            

            

                
        Moo::new(Domain::Unresolved(value.clone()))

            

        

            

                75
            

            

                
            

            

                
    }

            

        

            

                76
            

            

                
            

            

                
}

            

        

            

                77
            

            

                
            

            

                

            

        

            

                78
            

            

                
            

            

                
impl From<GroundDomain> for DomainPtr {

            

        

            

                79
            

            

                1075857
            

            

                
    fn from(value: GroundDomain) -> Self {

            

        

            

                80
            

            

                1075857
            

            

                
        Moo::new(Domain::Ground(Moo::new(value)))

            

        

            

                81
            

            

                1075857
            

            

                
    }

            

        

            

                82
            

            

                
            

            

                
}

            

        

            

                83
            

            

                
            

            

                

            

        

            

                84
            

            

                
            

            

                
impl From<UnresolvedDomain> for DomainPtr {

            

        

            

                85
            

            

                
            

            

                
    fn from(value: UnresolvedDomain) -> Self {

            

        

            

                86
            

            

                
            

            

                
        Moo::new(Domain::Unresolved(Moo::new(value)))

            

        

            

                87
            

            

                
            

            

                
    }

            

        

            

                88
            

            

                
            

            

                
}