Switched custom quantities to using a macro for generation.

generate-quantity/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "generate-quantity"
+description = "Macros for generating physical quantity type"
+version.workspace = true
+edition.workspace = true
+repository.workspace = true
+readme.workspace = true
+license.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies.quote]
+workspace = true
+[dependencies.syn]
+workspace = true

generate-quantity/src/lib.rs

@@ -0,0 +1,993 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Ident, LitStr, Token};
+
+// Define the input structure for the macro
+struct QuantityInput {
+    struct_name: Ident,
+    symbol: LitStr,
+}
+
+// Implement the parsing for the input structure
+impl Parse for QuantityInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let struct_name: Ident = input.parse()?;
+        input.parse::<Token![,]>()?;
+        let symbol: LitStr = input.parse()?;
+        Ok(QuantityInput {
+            struct_name,
+            symbol,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn quantity_type(input: TokenStream) -> TokenStream {
+    // Parse the input tokens into the QuantityInput structure
+    let QuantityInput {
+        struct_name,
+        symbol,
+    } = parse_macro_input!(input as QuantityInput);
+
+    // Generate the output code
+    let expanded = quote! {
+    #[derive(Copy, Clone, PartialEq, PartialOrd, Add, AddAssign, Sub, SubAssign, Display)]
+    #[display(fmt = "{} {}", _0, "Self::symbol()")]
+    #[repr(transparent)]
+    pub struct #struct_name<V: Value>(pub V);
+
+    impl<V: Value> Quantity<V> for #struct_name<V> {
+        #[inline(always)]
+        fn value(self) -> V {
+            self.0
+        }
+
+        #[inline(always)]
+        fn symbol() -> &'static str {
+            #symbol
+        }
+    }
+
+    impl #struct_name<u8> {
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<u16> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<u32> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<u64> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<u128> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<usize> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<i8> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<i16> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<i32> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<i64> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<i128> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<isize> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<f32> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f64(self) -> #struct_name<f64> {
+            #struct_name(self.0 as f64)
+        }
+    }
+
+    impl #struct_name<f64> {
+        #[inline(always)]
+        pub fn as_u8(self) -> #struct_name<u8> {
+            #struct_name(self.0 as u8)
+        }
+
+        #[inline(always)]
+        pub fn as_u16(self) -> #struct_name<u16> {
+            #struct_name(self.0 as u16)
+        }
+
+        #[inline(always)]
+        pub fn as_u32(self) -> #struct_name<u32> {
+            #struct_name(self.0 as u32)
+        }
+
+        #[inline(always)]
+        pub fn as_u64(self) -> #struct_name<u64> {
+            #struct_name(self.0 as u64)
+        }
+
+        #[inline(always)]
+        pub fn as_u128(self) -> #struct_name<u128> {
+            #struct_name(self.0 as u128)
+        }
+
+        #[inline(always)]
+        pub fn as_usize(self) -> #struct_name<usize> {
+            #struct_name(self.0 as usize)
+        }
+
+        #[inline(always)]
+        pub fn as_i8(self) -> #struct_name<i8> {
+            #struct_name(self.0 as i8)
+        }
+
+        #[inline(always)]
+        pub fn as_i16(self) -> #struct_name<i16> {
+            #struct_name(self.0 as i16)
+        }
+
+        #[inline(always)]
+        pub fn as_i32(self) -> #struct_name<i32> {
+            #struct_name(self.0 as i32)
+        }
+
+        #[inline(always)]
+        pub fn as_i64(self) -> #struct_name<i64> {
+            #struct_name(self.0 as i64)
+        }
+
+        #[inline(always)]
+        pub fn as_i128(self) -> #struct_name<i128> {
+            #struct_name(self.0 as i128)
+        }
+
+        #[inline(always)]
+        pub fn as_isize(self) -> #struct_name<isize> {
+            #struct_name(self.0 as isize)
+        }
+
+        #[inline(always)]
+        pub fn as_f32(self) -> #struct_name<f32> {
+            #struct_name(self.0 as f32)
+        }
+    }
+    };
+
+    TokenStream::from(expanded)
+}