Rename singleton! -> impl_anon!

Singleton usually refers to a type with a single, static instance.
The correct name is Anonymous Struct; impl_anon could
possibly support other anonymous types in the future.

Author: dhardy

README.md

@@ -159,17 +159,17 @@ impl_tools::impl_scope! {
 Caveat: `rustfmt` won't currently touch the contents. Hopefully that
 [can be fixed](https://github.com/rust-lang/rustfmt/pull/5538)!
 
-### Singleton
+### Impl Anon
 
-`singleton!` is a function-like macro to construct a single-use struct with
+`impl_anon!` is a function-like macro to construct a single-use struct with
 custom implementations (similar: [RFC#2604](https://github.com/rust-lang/rfcs/pull/2604)).
 
 Example:
 ```rust
 use std::fmt;
 fn main() {
     let world = "world";
-    let says_hello_world = impl_tools::singleton! {
+    let says_hello_world = impl_tools::impl_anon! {
         struct(&'static str = world);
         impl fmt::Display for Self {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

lib/src/singleton.rs lib/src/anon.rslib/src/singleton.rs renamed to lib/src/anon.rs

@@ -11,9 +11,9 @@ use syn::token::{Brace, Colon, Comma, Eq, Paren, Semi};
 use syn::{parse_quote, punctuated::Punctuated, spanned::Spanned};
 use syn::{Attribute, GenericParam, Generics, Ident, ItemImpl, Member, Token, Type, TypePath};
 
-/// A field of a [`Singleton`]
+/// A field of a [`Anon`]
 #[derive(Debug)]
-pub struct SingletonField {
+pub struct AnonField {
     /// Field attributes
     pub attrs: Vec<Attribute>,
     /// Field visibility
@@ -32,13 +32,13 @@ pub struct SingletonField {
     pub assignment: Option<(Eq, syn::Expr)>,
 }
 
-/// A struct with a single instantiation
+/// Contents of `impl_anon!`
 ///
-/// The singleton macro may be used to conveniently declare a struct's type,
+/// The impl_anon macro may be used to conveniently declare a struct's type,
 /// implementations and construct an instance.
 /// This struct represents the macro's input.
 #[derive(Debug)]
-pub struct Singleton {
+pub struct Anon {
     /// Struct attributes
     pub attrs: Vec<Attribute>,
     /// `struct` token
@@ -50,14 +50,14 @@ pub struct Singleton {
     /// Struct style: unit/tuple/regular
     pub style: StructStyle,
     /// Struct fields
-    pub fields: Punctuated<SingletonField, Comma>,
+    pub fields: Punctuated<AnonField, Comma>,
     /// (Explicit) struct implementations
     pub impls: Vec<ItemImpl>,
 }
 
-impl Singleton {
-    /// Convert to a [`SingletonScope`]
-    pub fn into_scope(mut self) -> SingletonScope {
+impl Anon {
+    /// Convert to a [`AnonScope`]
+    pub fn into_scope(mut self) -> AnonScope {
         let mut idfmt = IdentFormatter::new();
 
         let mut fields = Punctuated::<Field, Comma>::new();
@@ -221,7 +221,7 @@ impl Singleton {
         let scope = Scope {
             attrs: self.attrs,
             vis: syn::Visibility::Inherited,
-            ident: parse_quote! { _Singleton },
+            ident: parse_quote! { _Anon },
             generics: self.generics,
             item: ScopeItem::Struct {
                 token: self.token,
@@ -232,7 +232,7 @@ impl Singleton {
             generated: vec![],
         };
 
-        SingletonScope(scope, field_val_toks)
+        AnonScope(scope, field_val_toks)
     }
 }
 
@@ -243,21 +243,21 @@ impl Singleton {
 ///
 /// Tokens may be generated by [`Self::expand`].
 #[derive(Debug)]
-pub struct SingletonScope(Scope, TokenStream);
+pub struct AnonScope(Scope, TokenStream);
 
-impl std::ops::Deref for SingletonScope {
+impl std::ops::Deref for AnonScope {
     type Target = Scope;
     fn deref(&self) -> &Scope {
         &self.0
     }
 }
-impl std::ops::DerefMut for SingletonScope {
+impl std::ops::DerefMut for AnonScope {
     fn deref_mut(&mut self) -> &mut Scope {
         &mut self.0
     }
 }
 
-impl SingletonScope {
+impl AnonScope {
     /// Generate the [`TokenStream`]
     ///
     /// This is a convenience function. It is valid to, instead, (1) call
@@ -269,7 +269,7 @@ impl SingletonScope {
     }
 }
 
-impl ToTokens for SingletonScope {
+impl ToTokens for AnonScope {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let scope = &self.0;
         let field_val_toks = &self.1;
@@ -278,7 +278,7 @@ impl ToTokens for SingletonScope {
             {
                 #scope
 
-                _Singleton {
+                _Anon {
                     #field_val_toks
                 }
             }
@@ -389,7 +389,7 @@ mod parsing {
         })
     }
 
-    impl SingletonField {
+    impl AnonField {
         fn check_is_fixed(ty: &Type, input_span: Span) -> Result<()> {
             let is_fixed = match ty {
                 Type::ImplTrait(_) | Type::Infer(_) => false,
@@ -448,7 +448,7 @@ mod parsing {
                 Self::check_is_fixed(&ty, input.span())?;
             }
 
-            Ok(SingletonField {
+            Ok(AnonField {
                 attrs,
                 vis,
                 ident,
@@ -471,7 +471,7 @@ mod parsing {
                 Self::check_is_fixed(&ty, input.span())?;
             }
 
-            Ok(SingletonField {
+            Ok(AnonField {
                 attrs,
                 vis,
                 ident: None,
@@ -482,7 +482,7 @@ mod parsing {
         }
     }
 
-    impl Parse for Singleton {
+    impl Parse for Anon {
         fn parse(input: ParseStream) -> Result<Self> {
             let attrs = input.call(Attribute::parse_outer)?;
             let token = input.parse::<Token![struct]>()?;
@@ -500,7 +500,7 @@ mod parsing {
             if generics.where_clause.is_none() && lookahead.peek(Paren) {
                 let content;
                 let paren_token = parenthesized!(content in input);
-                fields = content.parse_terminated(SingletonField::parse_unnamed, Token![,])?;
+                fields = content.parse_terminated(AnonField::parse_unnamed, Token![,])?;
 
                 lookahead = input.lookahead1();
                 if lookahead.peek(Token![where]) {
@@ -517,7 +517,7 @@ mod parsing {
                 let content;
                 let brace_token = braced!(content in input);
                 style = StructStyle::Regular(brace_token);
-                fields = content.parse_terminated(SingletonField::parse_named, Token![,])?;
+                fields = content.parse_terminated(AnonField::parse_named, Token![,])?;
             } else if lookahead.peek(Semi) {
                 style = StructStyle::Unit(input.parse()?);
                 fields = Punctuated::new();
@@ -530,7 +530,7 @@ mod parsing {
                 impls.push(parse_impl(None, input)?);
             }
 
-            Ok(Singleton {
+            Ok(Anon {
                 attrs,
                 token,
                 generics,

lib/src/lib.rs

@@ -14,19 +14,19 @@
 #![allow(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::style)]
 
+mod anon;
 pub mod autoimpl;
 mod default;
 pub mod fields;
 mod for_deref;
 pub mod generics;
 mod scope;
-mod singleton;
 
+pub use anon::{Anon, AnonField, AnonScope};
 pub use default::{find_attr_impl_default, AttrImplDefault, ImplDefault};
 pub use for_deref::ForDeref;
 use proc_macro2::Span;
 pub use scope::{Scope, ScopeAttr, ScopeItem};
-pub use singleton::{Singleton, SingletonField, SingletonScope};
 use syn::Ident;
 
 /// Tool to make a formatted [`Ident`]

src/lib.rs

@@ -26,7 +26,7 @@
 //! -   Evaluation of advanced attribute macros, which may use field
 //!     initializers and read/write other impls within the scope
 //!
-//! `singleton!` is a function-like macro used to define and instantiate a
+//! `impl_anon!` is a function-like macro used to define and instantiate a
 //! unique (single-use) type. It supports everything supported by `impl_scope!`
 //! plus field initializers and (limited) automatic typing of fields.
 //!
@@ -309,7 +309,7 @@ pub fn autoimpl(attr: TokenStream, item: TokenStream) -> TokenStream {
     toks
 }
 
-/// Scope supporting `impl Self` and advanced attribute macros
+/// Implement a type with `impl Self` syntax
 ///
 /// This macro facilitates definition of a type (struct, enum or union) plus
 /// implementations via `impl Self { .. }` syntax: `Self` is expanded to the
@@ -377,7 +377,7 @@ pub fn impl_scope(input: TokenStream) -> TokenStream {
     scope.expand().into()
 }
 
-/// Construct a single-instance struct
+/// Construct an anonymous struct
 ///
 /// Rust doesn't currently support [`impl Trait { ... }` expressions](https://github.com/canndrew/rfcs/blob/impl-trait-expressions/text/0000-impl-trait-expressions.md)
 /// or implicit typing of struct fields. This macro is a **hack** allowing that.
@@ -387,7 +387,7 @@ pub fn impl_scope(input: TokenStream) -> TokenStream {
 /// use std::fmt;
 /// fn main() {
 ///     let world = "world";
-///     let says_hello_world = impl_tools::singleton! {
+///     let says_hello_world = impl_tools::impl_anon! {
 ///         struct(&'static str = world);
 ///         impl fmt::Display for Self {
 ///             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -417,11 +417,11 @@ pub fn impl_scope(input: TokenStream) -> TokenStream {
 /// `impl Trait` type expressions. These are substituted with generics on the
 /// type.
 ///
-/// Refer to [examples](https://github.com/search?q=singleton+repo%3Akas-gui%2Fkas+path%3Aexamples&type=Code) for usage.
+/// Refer to [examples](https://github.com/search?q=impl_anon+repo%3Akas-gui%2Fkas+path%3Aexamples&type=Code) for usage.
 #[proc_macro_error]
 #[proc_macro]
-pub fn singleton(input: TokenStream) -> TokenStream {
-    let mut scope = parse_macro_input!(input as lib::Singleton).into_scope();
+pub fn impl_anon(input: TokenStream) -> TokenStream {
+    let mut scope = parse_macro_input!(input as lib::Anon).into_scope();
     scope.apply_attrs(lib::find_attr_impl_default);
     scope.expand().into()
 }

tests/singleton.rs tests/impl_anon.rstests/singleton.rs renamed to tests/impl_anon.rs

@@ -1,11 +1,11 @@
-// Test singleton!
+// Test impl_anon!
 
 use core::fmt::Debug;
-use impl_tools::singleton;
+use impl_tools::impl_anon;
 
 #[test]
 fn a() {
-    let a = singleton! {
+    let a = impl_anon! {
         #[derive(Clone, Debug)]
         struct<T: Clone + Debug>(T = "abc");
 
@@ -21,7 +21,7 @@ fn a() {
 
 #[test]
 fn b() {
-    let b = singleton! {
+    let b = impl_anon! {
         #[derive(Clone, Debug)]
         struct<T: Clone + Debug> {
             t: T = 123,