fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {

        let tagtype = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

        let tagtype = tagtype

            .parse()

            .map_err(|_| RequestParserError::SyntaxError(1, tagtype.to_owned()))?;

        let filter = parse_filter(&mut parts)?;

        let group = if let Some("group") = parts.next() {

            let group = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

                group

                    .parse()

                    .map_err(|_| RequestParserError::SyntaxError(1, group.to_owned()))?,

            None

        debug_assert!(parts.next().is_none());

        Ok((Request::List(tagtype, filter, group), ""))

    }

    fn parse_response(

        parts: ResponseAttributes<'_>,

    ) -> Result<Self::Response, ResponseParserError> {

        debug_assert!({

            let key = parts.0.first().map(|(k, _)| k);

            parts.0.iter().all(|(k, _)| k == key.unwrap())

        let list = parts

            .0

            .iter()

            .map(|(k, v)| match v {

                GenericResponseValue::Text(value) => Ok(value.to_string()),

                    Err(ResponseParserError::UnexpectedPropertyType(k, "Binary"))

            })

            .collect::<Result<Vec<_>, ResponseParserError>>()?;

        Ok(list)

    }