Remove the macro

Author: T0mstone

build.rs

@@ -8,11 +8,8 @@ type StrResult<T> = Result<T, String>;
 #[path = "src/shared.rs"]
 mod shared;
 
-self::shared::declare_types! {
-    <'a>
-    str = &'a str,
-    List = Vec<_>
-}
+/// A module of definitions.
+struct Module<'a>(Vec<(&'a str, Binding<'a>)>);
 
 impl<'a> Module<'a> {
     fn new(mut list: Vec<(&'a str, Binding<'a>)>) -> Self {
@@ -21,6 +18,24 @@ impl<'a> Module<'a> {
     }
 }
 
+/// A definition bound in a module, with metadata.
+struct Binding<'a> {
+    def: Def<'a>,
+    deprecation: Option<&'a str>,
+}
+
+/// A definition in a module.
+enum Def<'a> {
+    Symbol(Symbol<'a>),
+    Module(Module<'a>),
+}
+
+/// A symbol, either a leaf or with modifiers.
+enum Symbol<'a> {
+    Single(char),
+    Multi(Vec<(ModifierSet<&'a str>, char)>),
+}
+
 /// A single line during parsing.
 #[derive(Debug, Copy, Clone)]
 enum Line<'a> {

src/lib.rs

@@ -12,12 +12,9 @@ pub use self::shared::ModifierSet;
 
 mod shared;
 
-type StaticSlice<T> = &'static [T];
-self::shared::declare_types! {
-    derive(Debug, Copy, Clone),
-    str = &'static str,
-    List = StaticSlice<_>
-}
+/// A module of definitions.
+#[derive(Debug, Copy, Clone)]
+pub struct Module(&'static [(&'static str, Binding)]);
 
 impl Module {
     /// Try to get a bound definition in the module.
@@ -34,6 +31,40 @@ impl Module {
     }
 }
 
+/// A definition bound in a module, with metadata.
+#[derive(Debug, Copy, Clone)]
+pub struct Binding {
+    /// The bound definition.
+    pub def: Def,
+    /// A deprecation message for the definition, if it is deprecated.
+    pub deprecation: Option<&'static str>,
+}
+
+impl Binding {
+    /// Create a new bound definition.
+    pub const fn new(definition: Def) -> Self {
+        Self { def: definition, deprecation: None }
+    }
+}
+
+/// A definition in a module.
+#[derive(Debug, Copy, Clone)]
+pub enum Def {
+    /// A symbol, potentially with modifiers.
+    Symbol(Symbol),
+    /// A nested module.
+    Module(Module),
+}
+
+/// A symbol, either a leaf or with modifiers.
+#[derive(Debug, Copy, Clone)]
+pub enum Symbol {
+    /// A symbol without modifiers.
+    Single(char),
+    /// A symbol with named modifiers. The symbol defaults to its first variant.
+    Multi(&'static [(ModifierSet<&'static str>, char)]),
+}
+
 impl Symbol {
     /// Get the symbol's character for a given set of modifiers.
     pub fn get(&self, modifs: ModifierSet<&str>) -> Option<char> {

src/shared.rs

@@ -1,54 +1,5 @@
-macro_rules! declare_types {
-    ($(<$lt:lifetime>)?
-        $(derive($($Der:ident),*),)?
-        str = $s:ty,
-        List = $List:ident<_>
-    ) => {
-        /// A module of definitions.
-        $(#[derive($($Der),*)])?
-        pub struct Module<$($lt)?>($List<($s, Binding<$($lt)?>)>);
-
-        /// A definition bound in a module, with metadata.
-        $(#[derive($($Der),*)])?
-        pub struct Binding<$($lt)?> {
-            /// The bound definition.
-            pub def: Def<$($lt)?>,
-            /// A deprecation message for the definition, if it is deprecated.
-            pub deprecation: Option<$s>,
-        }
-
-        impl<$($lt)?> Binding<$($lt)?> {
-            /// Create a new bound definition.
-            pub const fn new(definition: Def<$($lt)?>) -> Self {
-                Self { def: definition, deprecation: None }
-            }
-        }
-
-        /// A definition in a module.
-        $(#[derive($($Der),*)])?
-        pub enum Def<$($lt)?> {
-            /// A symbol, potentially with modifiers.
-            Symbol(Symbol<$($lt)?>),
-            /// A nested module.
-            Module(Module<$($lt)?>),
-        }
-
-        /// A symbol, either a leaf or with modifiers.
-        $(#[derive($($Der),*)])?
-        pub enum Symbol<$($lt)?> {
-            /// A symbol without modifiers.
-            Single(char),
-            /// A symbol with named modifiers.
-            /// The symbol defaults to its first variant.
-            Multi($List<(ModifierSet<$s>, char)>),
-        }
-    };
-}
-
 use std::ops::Deref;
 
-pub(crate) use declare_types;
-
 /// A set of modifiers.
 #[derive(Debug, Copy, Clone)]
 // note: the visibility needs to be `pub(crate)`,