mod check;

#[derive(Debug, Error, Diagnostic)]
pub enum IoOrParseError {
    #[error("could not read file: {0}")]
    IoError(#[from] std::io::Error),
    #[error("could not parse file: {0}")]
    ParseError(#[from] knuffel::Error<LineSpan>),
}

    type Error;
    fn parse(self) -> Result<DocumentAst, Self::Error>;

    fn parse(self) -> Result<DocumentAst, IoOrParseError>;

    type Error = std::convert::Infallible;
    fn parse(self) -> Result<DocumentAst, Self::Error> {

    fn parse(self) -> Result<DocumentAst, IoOrParseError> {

    type Error = knuffel::Error<LineSpan>;
    fn parse(self) -> Result<DocumentAst, Self::Error> {
        knuffel::parse_ast("<text input>", self)

    fn parse(self) -> Result<DocumentAst, IoOrParseError> {
        let result = knuffel::parse_ast("<text input>", self)?;
        Ok(result)

}
#[derive(Debug, Error, Diagnostic)]
pub enum IoOrParseError {
    #[error("could not read file: {0}")]
    IoError(#[from] std::io::Error),
    #[error("could not parse file: {0}")]
    ParseError(#[from] knuffel::Error<LineSpan>),

    type Error = IoOrParseError;
    fn parse(self) -> Result<DocumentAst, Self::Error> {

    fn parse(self) -> Result<DocumentAst, IoOrParseError> {

pub enum MatchError<ParseError> {
    ParseError(ParseError),

#[derive(Debug, Error, Diagnostic)]
pub enum CheckFailure {
    #[error("failed to read document: {0}")]
    ParseError(#[from] IoOrParseError),
    #[error(transparent)]
    ValidationFailure(#[from] check::CheckFailure),

    fn check_matches<D: ParseToDocumentAst>(document: D) -> Result<(), MatchError<D::Error>>;

    fn check_matches<D: ParseToDocumentAst>(&self, document: D) -> Result<(), CheckFailure>;

    fn check_matches<D: ParseToDocumentAst>(document: D) -> Result<(), MatchError<D::Error>> {
        todo!()

    fn check_matches<D: ParseToDocumentAst>(&self, document: D) -> Result<(), CheckFailure> {
        let document = document.parse()?;
        let _ = check::check(document, self)?;
        Ok(())

use kdl_schema::Schema;
use miette::Diagnostic;
use thiserror::Error;
use super::DocumentAst;
#[derive(Debug, Error, Diagnostic)]
pub enum CheckFailure {}
pub(crate) fn check(document: DocumentAst, schema: &Schema) -> Result<(), CheckFailure> {
    todo!()
}