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

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

        let sticker_type = sticker_type

            .parse()

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

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

        let uri = uri

            .parse()

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

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

        Ok((Request::StickerList(sticker_type, uri), ""))

    }

    fn parse_response(

        parts: ResponseAttributes<'_>,

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

        let parts: Vec<_> = parts.into();

        debug_assert!(parts.iter().all(|(k, _)| *k == "sticker"));

        let result = parts

            .iter()

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

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

                GenericResponseValue::Binary(_) => Err(

                    ResponseParserError::UnexpectedPropertyType("sticker", "Binary"),

                ),

            })

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

        result

            .into_iter()

            .map(|v| {

                // TODO: This assumes the first = is the only one.

                //       See: https://github.com/MusicPlayerDaemon/MPD/issues/2166

                let mut split = v.split('=');

                let key = split.next().ok_or(ResponseParserError::SyntaxError(0, v))?;

                let value = split.next().ok_or(ResponseParserError::SyntaxError(1, v))?;

                Ok((key.to_string(), value.to_string()))

            })

            .collect::<Result<HashMap<_, _>, ResponseParserError>>()

    }