former_types/collection/

hash_set.rs

//! This module provides a builder pattern implementation (`HashSetFormer`) for `HashSet`-like collections. It is designed to extend the builder pattern, allowing for fluent and dynamic construction of sets within custom data structures.

use crate::*;
use collection_tools::HashSet;

impl< K > Collection for HashSet< K >
where
  K : core::cmp::Eq + core::hash::Hash,
{
  type Entry = K;
  type Val = K;

  #[ inline( always ) ]
  fn entry_to_val( e : Self::Entry ) -> Self::Val
  {
    e
  }

}

impl< K > CollectionAdd for HashSet< K >
where
  K : core::cmp::Eq + core::hash::Hash,
{
  // type Entry = K;
  // type Val = K;

  #[ inline( always ) ]
  fn add( &mut self, e : Self::Entry ) -> bool
  {
    self.insert( e )
  }

}

impl< K > CollectionAssign for HashSet< K >
where
  K : core::cmp::Eq + core::hash::Hash,
{
  // type Entry = K;

  fn assign< Elements >( &mut self, elements : Elements ) -> usize
  where
    Elements : IntoIterator< Item = Self::Entry >
  {
    let initial_len = self.len();
    self.extend( elements );
    self.len() - initial_len
  }
}

impl< K > CollectionValToEntry< K > for HashSet< K >
where
  K : core::cmp::Eq + core::hash::Hash,
{
  type Entry = K;
  #[ inline( always ) ]
  fn val_to_entry( val : K ) -> Self::Entry
  {
    val
  }
}

// /// A trait for collections behaving like a `HashSet`, allowing insertion operations.
// ///
// /// Implementing this trait enables the associated formed to be used with `HashSetFormer`,
// /// facilitating a builder pattern that is both intuitive and concise.
// ///
// /// # Example Implementation
// ///
// /// Implementing `HashSetLike` for `std::collections::HashSet`:
// ///
//
// pub trait HashSetLike< K >
// where
//   K : core::cmp::Eq + core::hash::Hash,
// {
//   /// Inserts a key-value pair into the map.
//   fn insert( &mut self, element : K ) -> Option< K >;
// }
//
// // impl< K > HashSetLike< K > for HashSet< K >
// // where
// //   K : core::cmp::Eq + core::hash::Hash,
// // {
// //   fn insert( &mut self, element : K ) -> Option< K >
// //   {
// //     HashSet::replace( self, element )
// //   }
// // }

// = storage

impl< K > Storage
for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  // type Formed = HashSet< K >;
  type Preformed = HashSet< K >;
}

impl< K > StoragePreform
for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  // type Preformed = HashSet< K >;
  fn preform( self ) -> Self::Preformed
  {
    self
  }
}

// = definition

/// Represents the formation definition for a hash set-like collection within the former framework.
///
/// This structure defines the essential elements required to form a hash set-like collection, detailing
/// the type of elements, the contextual environment during formation, the final formed type, and the
/// behavior at the end of the formation process. It is designed to support the construction and configuration
/// of hash set collections with dynamic characteristics and behaviors.
///
/// # Type Parameters
/// - `K`: The type of elements in the hash set.
/// - `Context`: The optional context provided during the formation process.
/// - `Formed`: The type of the entity produced, typically a `HashSet<K>`.
/// - `End`: A trait defining the end behavior of the formation process, managing how the hash set is finalized.
///

#[ derive( Debug, Default ) ]
pub struct HashSetDefinition< K, Context = (), Formed = HashSet< K >, End = ReturnStorage >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
  End : FormingEnd< HashSetDefinitionTypes< K, Context, Formed > >,
{
  _phantom : core::marker::PhantomData< ( K, Context, Formed, End ) >,
}

impl< K, Context, Formed, End > FormerDefinition
for HashSetDefinition< K, Context, Formed, End >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
  End : FormingEnd< HashSetDefinitionTypes< K, Context, Formed > >,
{
  type Storage = HashSet< K >;
  type Formed = Formed;
  type Context = Context;

  type Types = HashSetDefinitionTypes< K, Context, Formed >;
  type End = End;
}

// = definition types

/// Holds the generic parameters for the `HashSetDefinition`.
///
/// This struct encapsulates the type relationships and characteristics essential for the formation process
/// of a `HashSet`, including the storage type, the context, and the type ultimately formed. It ensures that
/// these elements are congruent and coherent throughout the lifecycle of the hash set formation.
///

#[ derive( Debug, Default ) ]
pub struct HashSetDefinitionTypes< K, Context = (), Formed = HashSet< K > >
{
  _phantom : core::marker::PhantomData< ( K, Context, Formed ) >,
}

impl< K, Context, Formed > FormerDefinitionTypes
for HashSetDefinitionTypes< K, Context, Formed >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  type Storage = HashSet< K >;
  type Formed = Formed;
  type Context = Context;
}

// = mutator

impl< K, Context, Formed > FormerMutator
for HashSetDefinitionTypes< K, Context, Formed >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
}

// = entity to

impl< K, Definition > EntityToFormer< Definition > for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
  Definition : FormerDefinition
  <
    Storage = HashSet< K >,
    Types = HashSetDefinitionTypes
    <
      K,
      < Definition as definition::FormerDefinition >::Context,
      < Definition as definition::FormerDefinition >::Formed,
    >,
  >,
  Definition::End : forming::FormingEnd< Definition::Types >,
{
  type Former = HashSetFormer< K, Definition::Context, Definition::Formed, Definition::End >;
}

impl< K > crate::EntityToStorage
for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  type Storage = HashSet< K >;
}

impl< K, Context, Formed, End > crate::EntityToDefinition< Context, Formed, End >
for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
  End : crate::FormingEnd< HashSetDefinitionTypes< K, Context, Formed > >,
{
  type Definition = HashSetDefinition< K, Context, Formed, End >;
  type Types = HashSetDefinitionTypes< K, Context, Formed >;
}

impl< K, Context, Formed > crate::EntityToDefinitionTypes< Context, Formed >
for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  type Types = HashSetDefinitionTypes< K, Context, Formed >;
}

// = subformer

/// Provides a concise alias for `CollectionFormer` configured specifically for `HashSet`-like collections.
///
/// `HashSetFormer` simplifies the creation of `HashSet` collections within builder patterns by leveraging
/// the `CollectionFormer` with predefined settings. This approach minimizes boilerplate code and enhances
/// readability, making it ideal for fluent and expressive construction of set collections within custom data structures.
///

pub type HashSetFormer< K, Context, Formed, End > =
CollectionFormer::< K, HashSetDefinition< K, Context, Formed, End > >;

// = extension

/// Provides an extension method for `HashSet` to facilitate the use of the builder pattern.
///
/// This trait extends `HashSet`, enabling direct use of the `HashSetFormer` interface for fluent and expressive
/// set construction. It simplifies the process of building `HashSet` instances by providing a straightforward
/// way to start the builder pattern with default context and termination behavior.
///

pub trait HashSetExt< K > : sealed::Sealed
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  /// Initializes a builder pattern for `HashSet` using a default `HashSetFormer`.
  fn former() -> HashSetFormer< K, (), HashSet< K >, ReturnStorage >;
}

impl< K > HashSetExt< K > for HashSet< K >
where
  K : ::core::cmp::Eq + ::core::hash::Hash,
{
  fn former() -> HashSetFormer< K, (), HashSet< K >, ReturnStorage >
  {
    HashSetFormer::< K, (), HashSet< K >, ReturnStorage >::new( ReturnStorage::default() )
  }
}

mod sealed
{
  use super::HashSet;
  pub trait Sealed {}
  impl< K > Sealed for HashSet< K > {}
}