use crate::*;

// TODO DEPRECATE:

/// `T` + [Dsl] -> `Self`.
pub trait FromDsl<T>: Sized {
    fn from_dsl (state: &T, dsl: &impl Dsl) -> Perhaps<Self>;
    fn from_dsl_or (state: &T, dsl: &impl Dsl, err: Box<dyn Error>) -> Usually<Self> {
        Self::from_dsl(state, dsl)?.ok_or(err)
    }
    fn from_dsl_or_else (state: &T, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<Self> {
        Self::from_dsl(state, dsl)?.ok_or_else(err)
    }
}

/// `self` + [Dsl] -> `T`
pub trait DslInto<T> {
    fn dsl_into (&self, dsl: &impl Dsl) -> Perhaps<T>;
    fn dsl_into_or (&self, dsl: &impl Dsl, err: Box<dyn Error>) -> Usually<T> {
        self.dsl_into(dsl)?.ok_or(err)
    }
    fn dsl_into_or_else (&self, dsl: &impl Dsl, err: impl Fn()->Box<dyn Error>) -> Usually<T> {
        self.dsl_into(dsl)?.ok_or_else(err)
    }
}

/// `self` + `T` -> [Dsl]
pub trait DslFrom<T> {
    fn dsl_from (&self, val: &T) -> Perhaps<impl Dsl>;
    fn dsl_from_or (&self, val: &T, err: Box<dyn Error>) -> Usually<impl Dsl> {
        self.dsl_from(val)?.ok_or(err)
    }
    fn dsl_from_or_else (&self, val: &T, err: impl Fn()->Box<dyn Error>) -> Usually<impl Dsl> {
        self.dsl_from(val)?.ok_or_else(err)
    }
}

/// `self` + `T` + -> [Dsl]
pub trait IntoDsl<T> {
    fn into_dsl (&self, state: &T) -> Perhaps<impl Dsl>;
    fn into_dsl_or (&self, state: &T, err: Box<dyn Error>) -> Usually<impl Dsl> {
        self.into_dsl(state)?.ok_or(err)
    }
    fn into_dsl_or_else (&self, state: &T, err: impl Fn()->Box<dyn Error>) -> Usually<impl Dsl> {
        self.into_dsl(state)?.ok_or_else(err)
    }
}

//impl<'s, T: FromDsl<U>, U> DslInto<'s, T> for U {
    //fn dsl_into (&self, dsl: &impl Dsl) -> Perhaps<T> {
        //T::from_dsl(self, dsl)
    //}
//}

//impl<T: DslFrom<U>, U> IntoDsl<T> for U {
    //fn into_dsl (&self, state: &T) -> Perhaps<impl Dsl> {
        //T::dsl_from(state, self)
    //}
//}