Use macros for creating the intermediate stage.

This is to make it easier to change function signatures by consolidating the places where the signatures exist.

src/intermediate/plain_list_item.rs

@@ -1,8 +1,8 @@
-use crate::error::CustomError;
-
+use super::macros::intermediate;
 use super::registry::Registry;
 use super::IElement;
 use super::IObject;
+use crate::error::CustomError;
 
 #[derive(Debug, Clone)]
 pub(crate) struct IPlainListItem {
@@ -10,27 +10,22 @@ pub(crate) struct IPlainListItem {
     pub(crate) children: Vec<IElement>,
 }
 
-impl IPlainListItem {
-    pub(crate) async fn new<'b, 'parse>(
-        registry: &'b mut Registry<'parse>,
-        original: &'b organic::types::PlainListItem<'parse>,
-    ) -> Result<IPlainListItem, CustomError> {
-        let tag = {
-            let mut ret = Vec::new();
-            for obj in original.tag.iter() {
-                ret.push(IObject::new(registry, obj).await?);
-            }
-            ret
-        };
+intermediate!(IPlainListItem, PlainListItem, |registry, original| async {
+    let tag = {
+        let mut ret = Vec::new();
+        for obj in original.tag.iter() {
+            ret.push(IObject::new(registry, obj).await?);
+        }
+        ret
+    };
 
-        let children = {
-            let mut ret = Vec::new();
-            for elem in original.children.iter() {
-                ret.push(IElement::new(registry, elem).await?);
-            }
-            ret
-        };
+    let children = {
+        let mut ret = Vec::new();
+        for elem in original.children.iter() {
+            ret.push(IElement::new(registry, elem).await?);
+        }
+        ret
+    };
 
-        Ok(IPlainListItem { tag, children })
-    }
-}
+    Ok(IPlainListItem { tag, children })
+});