Merge pull request #30 from strict-types/ident

Improvements for Ident type

Author: dr-orlovsky

rust/src/ident.rs

@@ -120,6 +120,12 @@ impl Debug for Ident {
     }
 }
 
+impl Ident {
+    pub fn from_uint(val: impl Into<u64>) -> Ident {
+        Self::try_from(format!("_{}", val.into())).expect("always a valid identifier")
+    }
+}
+
 impl StrictDumb for Ident {
     fn strict_dumb() -> Self { Self::from("Dumb") }
 }
@@ -169,7 +175,7 @@ impl From<&'static str> for TypeName {
 impl TryFrom<String> for TypeName {
     type Error = InvalidIdent;
 
-    fn try_from(s: String) -> Result<Self, Self::Error> { Ident::try_from(s).map(Self) }
+    fn try_from(s: String) -> Result<Self, Self::Error> { Self::from_str(&s) }
 }
 
 impl Debug for TypeName {
@@ -178,6 +184,13 @@ impl Debug for TypeName {
     }
 }
 
+impl TypeName {
+    pub fn as_str(&self) -> &str { self.0.as_str() }
+    pub fn as_ident(&self) -> &Ident { &self.0 }
+    pub fn to_ident(&self) -> Ident { self.clone().into() }
+    pub fn into_ident(self) -> Ident { self.into() }
+}
+
 impl_strict_newtype!(TypeName, STRICT_TYPES_LIB);
 
 #[derive(Wrapper, WrapperMut, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, From)]
@@ -197,7 +210,7 @@ impl From<&'static str> for FieldName {
 impl TryFrom<String> for FieldName {
     type Error = InvalidIdent;
 
-    fn try_from(s: String) -> Result<Self, Self::Error> { Ident::try_from(s).map(Self) }
+    fn try_from(s: String) -> Result<Self, Self::Error> { Self::from_str(&s) }
 }
 
 impl Debug for FieldName {
@@ -208,11 +221,47 @@ impl Debug for FieldName {
 
 impl FieldName {
     pub fn as_str(&self) -> &str { self.0.as_str() }
+    pub fn as_ident(&self) -> &Ident { &self.0 }
+    pub fn to_ident(&self) -> Ident { self.clone().into() }
+    pub fn into_ident(self) -> Ident { self.into() }
 }
 
 impl_strict_newtype!(FieldName, STRICT_TYPES_LIB);
 
-pub type VariantName = FieldName;
+#[derive(Wrapper, WrapperMut, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, From)]
+#[wrapper(Deref, Display, FromStr)]
+#[wrapper_mut(DerefMut)]
+#[cfg_attr(
+    feature = "serde",
+    derive(Serialize, Deserialize),
+    serde(crate = "serde_crate", transparent)
+)]
+pub struct VariantName(Ident);
+
+impl From<&'static str> for VariantName {
+    fn from(ident: &'static str) -> Self { VariantName(Ident::from(ident)) }
+}
+
+impl TryFrom<String> for VariantName {
+    type Error = InvalidIdent;
+
+    fn try_from(s: String) -> Result<Self, Self::Error> { Self::from_str(&s) }
+}
+
+impl Debug for VariantName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("VariantName").field(&self.as_str()).finish()
+    }
+}
+
+impl VariantName {
+    pub fn as_str(&self) -> &str { self.0.as_str() }
+    pub fn as_ident(&self) -> &Ident { &self.0 }
+    pub fn to_ident(&self) -> Ident { self.clone().into() }
+    pub fn into_ident(self) -> Ident { self.into() }
+}
+
+impl_strict_newtype!(VariantName, STRICT_TYPES_LIB);
 
 #[derive(Wrapper, WrapperMut, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, From)]
 #[wrapper(Deref, Display, FromStr)]
@@ -231,7 +280,7 @@ impl From<&'static str> for LibName {
 impl TryFrom<String> for LibName {
     type Error = InvalidIdent;
 
-    fn try_from(s: String) -> Result<Self, Self::Error> { Ident::try_from(s).map(Self) }
+    fn try_from(s: String) -> Result<Self, Self::Error> { Self::from_str(&s) }
 }
 
 impl Debug for LibName {
@@ -240,4 +289,11 @@ impl Debug for LibName {
     }
 }
 
+impl LibName {
+    pub fn as_str(&self) -> &str { self.0.as_str() }
+    pub fn as_ident(&self) -> &Ident { &self.0 }
+    pub fn to_ident(&self) -> Ident { self.clone().into() }
+    pub fn into_ident(self) -> Ident { self.into() }
+}
+
 impl_strict_newtype!(LibName, STRICT_TYPES_LIB);

rust/src/macros.rs

@@ -98,6 +98,16 @@ macro_rules! impl_strict_struct {
     };
 }
 
+#[macro_export]
+macro_rules! ident {
+    ($name:literal) => {
+        $crate::Ident::from($name).into()
+    };
+    ($name:expr) => {
+        $crate::Ident::from($name).into()
+    };
+}
+
 #[macro_export]
 macro_rules! tn {
     ($name:literal) => {

rust/src/traits.rs

@@ -27,7 +27,7 @@ use amplify::confinement::{Collection, Confined};
 use amplify::num::u24;
 use amplify::Wrapper;
 
-use super::DecodeError;
+use super::{DecodeError, VariantName};
 use crate::{
     DeserializeError, FieldName, Primitive, SerializeError, Sizing, StrictDumb, StrictEnum,
     StrictReader, StrictStruct, StrictSum, StrictTuple, StrictType, StrictUnion, StrictWriter,
@@ -147,7 +147,7 @@ pub trait TypedRead: Sized {
 
     fn read_union<T: StrictUnion>(
         &mut self,
-        inner: impl FnOnce(FieldName, &mut Self::UnionReader) -> Result<T, DecodeError>,
+        inner: impl FnOnce(VariantName, &mut Self::UnionReader) -> Result<T, DecodeError>,
     ) -> Result<T, DecodeError>;
 
     fn read_enum<T: StrictEnum>(&mut self) -> Result<T, DecodeError>
@@ -234,13 +234,13 @@ pub trait ReadStruct {
 pub trait DefineEnum: Sized {
     type Parent: TypedWrite;
     type EnumWriter: WriteEnum<Parent = Self::Parent>;
-    fn define_variant(self, name: FieldName) -> Self;
+    fn define_variant(self, name: VariantName) -> Self;
     fn complete(self) -> Self::EnumWriter;
 }
 
 pub trait WriteEnum: Sized {
     type Parent: TypedWrite;
-    fn write_variant(self, name: FieldName) -> io::Result<Self>;
+    fn write_variant(self, name: VariantName) -> io::Result<Self>;
     fn complete(self) -> Self::Parent;
 }
 
@@ -250,14 +250,18 @@ pub trait DefineUnion: Sized {
     type StructDefiner: DefineStruct<Parent = Self>;
     type UnionWriter: WriteUnion<Parent = Self::Parent>;
 
-    fn define_unit(self, name: FieldName) -> Self;
-    fn define_newtype<T: StrictEncode + StrictDumb>(self, name: FieldName) -> Self {
+    fn define_unit(self, name: VariantName) -> Self;
+    fn define_newtype<T: StrictEncode + StrictDumb>(self, name: VariantName) -> Self {
         self.define_tuple(name, |definer| definer.define_field::<T>().complete())
     }
-    fn define_tuple(self, name: FieldName, inner: impl FnOnce(Self::TupleDefiner) -> Self) -> Self;
+    fn define_tuple(
+        self,
+        name: VariantName,
+        inner: impl FnOnce(Self::TupleDefiner) -> Self,
+    ) -> Self;
     fn define_struct(
         self,
-        name: FieldName,
+        name: VariantName,
         inner: impl FnOnce(Self::StructDefiner) -> Self,
     ) -> Self;
 
@@ -269,18 +273,18 @@ pub trait WriteUnion: Sized {
     type TupleWriter: WriteTuple<Parent = Self>;
     type StructWriter: WriteStruct<Parent = Self>;
 
-    fn write_unit(self, name: FieldName) -> io::Result<Self>;
-    fn write_newtype(self, name: FieldName, value: &impl StrictEncode) -> io::Result<Self> {
+    fn write_unit(self, name: VariantName) -> io::Result<Self>;
+    fn write_newtype(self, name: VariantName, value: &impl StrictEncode) -> io::Result<Self> {
         self.write_tuple(name, |writer| Ok(writer.write_field(value)?.complete()))
     }
     fn write_tuple(
         self,
-        name: FieldName,
+        name: VariantName,
         inner: impl FnOnce(Self::TupleWriter) -> io::Result<Self>,
     ) -> io::Result<Self>;
     fn write_struct(
         self,
-        name: FieldName,
+        name: VariantName,
         inner: impl FnOnce(Self::StructWriter) -> io::Result<Self>,
     ) -> io::Result<Self>;
 

rust/src/types.rs

@@ -24,7 +24,7 @@ use std::collections::BTreeSet;
 use std::fmt::{Debug, Display};
 use std::marker::PhantomData;
 
-use crate::{FieldName, LibName, TypeName};
+use crate::{LibName, TypeName, VariantName};
 
 #[derive(Clone, Eq, PartialEq, Debug, Display, Error)]
 #[display("unexpected variant {1} for enum or union {0:?}")]
@@ -155,7 +155,7 @@ pub trait StrictSum: StrictType {
         );
     }
 
-    fn variant_name_by_tag(tag: u8) -> Option<FieldName> {
+    fn variant_name_by_tag(tag: u8) -> Option<VariantName> {
         Self::ALL_VARIANTS
             .iter()
             .find(|(n, _)| *n == tag)
@@ -195,7 +195,7 @@ where
     Self: StrictSum + Copy + TryFrom<u8, Error = VariantError<u8>>,
     u8: From<Self>,
 {
-    fn from_variant_name(name: &FieldName) -> Result<Self, VariantError<&FieldName>> {
+    fn from_variant_name(name: &VariantName) -> Result<Self, VariantError<&VariantName>> {
         for (tag, n) in Self::ALL_VARIANTS {
             if *n == name.as_str() {
                 return Self::try_from(*tag).map_err(|_| VariantError(Self::strict_name(), name));