#![doc(html_root_url = "https://docs.rs/col_macros/0.1.6/")]

//! This crate is a collection of general purporse collection macros.

#[doc(hidden)]
pub use high_mem_utils::{DontDrop, DontDropOpt, DropBy};
#[doc(hidden)]
pub use std::{hint::unreachable_unchecked, mem::transmute_copy};
pub use std::mem::{MaybeUninit, transmute};
#[doc(hidden)]
pub use macro_helper::{expansion_bucle, expansion_bucle_counted};
#[doc(hidden)]
pub use compile_ops::{add, sub};

pub mod types {
    //! These are the standard collection types aliased with the names that their respective macros 
    //! depends, import them if you do not want define to them.

    /// [vector!](../macro.vector.html)
    pub type Vector<T> = Vec<T>;
    /// [own_slice!](../macro.own_slice)
    #[cfg(feature = "owned_slice")]
    pub type OwnedSlice<T> = Box<[T]>;
    /// [vec_deque!](../macro.vec_deque.html)
    pub type Deque<T> = std::collections::VecDeque<T>;
    /// [hash_map!](../macro.hash_map.html)
    pub type Map<K, V> = std::collections::HashMap<K, V>;
    /// [hash_set!](../macro.hash_set.html)
    pub type Set<K> = std::collections::HashSet<K>;
    /// [btree_map!](../macro.btree_map.html)
    pub type BTMap<K, V> = std::collections::BTreeMap<K, V>;
    /// [btree_set!](../macro.btree_set.html)
    pub type BTSet<K> = std::collections::BTreeSet<K>;
}

/// Construct or update a vector of type Vector\<T\> which can be and is an alias to Vec<T> in the types module.
///
/// Collections with the capacity,set_len methods whose deref to [T] are accepted.  
/// 
/// Why not vec!?
/// 
/// 1. Does not take in account where the input is an identifier or literal and does not apply optimizations
/// based on that.
/// 
/// 2. It is not general purpose,it always construct a Vec<T>. 
///
/// # Examples
///
/// ```
/// #![feature(proc_macro_hygiene)]
/// use col_macros::vector;
/// use col_macros::types::Vector;
///
/// let mut vec1: Vec<usize> = vector![1, 2, 3];
/// let eight: usize = 8;
///
/// assert_eq!(vec1, vec![1, 2, 3]);
///
/// vector![for &mut vec1, ins 4, 5, 6, eight].push(7); // we still have a mutable reference
///
/// assert_eq!(vec1, vector![1, 2, 3, 4, 5, 6, eight, 7]);
///
/// assert_eq!(vec![eight; 8], vector![eight; eight]);
/// assert_eq!(vec![8, 8, 8], vector![eight, eight, eight]);
/// assert_eq!(vec![8, 8, 8], vector![eight, eight, 8]);
/// ```
#[macro_export]
macro_rules! vector {
    (for $map:expr, ins $( $k:literal ),*) => {
        {
            fn conflictless_large_name<T>(map: &mut Vector<T>) -> &mut Vector<T> {
                let mut actual_len = $crate::DontDrop(map.len());
                let actual_ptr = &actual_len.0 as *const usize;
                map.reserve($crate::add!(0 $(, 1!$k)*));
                let mut map = $crate::DropBy::new(map, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                    Some(ref mut a) => a.as_mut_ptr(),
                                    None => $crate::unreachable_unchecked(),
                                };

                    $(
                        let k = $crate::transmute_copy(&$k);
                        map_ptr.add(actual_len.0).write(k);
                        actual_len.0 += 1;
                    )*

                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name($map)
        }
    };

    (for $map:expr, ins $( $k:expr ),*) => { // note: all the patterns need a function in the transcriber,this is so for annotate the type of the vector
        {
            fn conflictless_large_name<T>(map: &mut Vector<T>, arr: [T; $crate::add!(0 $(, 1!$k)*)]) -> &mut Vector<T> {
                let mut actual_len = $crate::DontDrop(map.len());
                let actual_ptr = &actual_len.0 as *const usize;
                map.reserve($crate::add!(0 $(, 1!$k)*));
                let mut map = $crate::DropBy::new(map, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                    Some(ref mut a) => a.as_mut_ptr(),
                                    None => $crate::unreachable_unchecked(),
                                };

                    let arr = $crate::DontDropOpt::new(arr);
                    let mut arr_ptr = match *arr {
                        Some(ref e) => e.as_ptr(),
                        None => unsafe { $crate::unreachable_unchecked() }, 
                    };

                    map_ptr.add(actual_len.0).write(arr_ptr.read());
                    arr_ptr = arr_ptr.add(1);
                    actual_len.0 += 1;
                    
                    $crate::expansion_bucle_counted!(
                        map_ptr.add(actual_len.0).write(arr_ptr.add(rep_count).read());
                        actual_len.0 += 1; => 0 $( + 1!$k)* - 1
                    );

                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name($map, [$( $k ),*])
        }
    };

    (for $map:tt, ins $( $k:tt ,)*) => {
        $crate::vector!(for $map, ins $( $k ),*)
    };

    ( $( $k:literal ),*) => {
        {
            fn conflictless_large_name<T>() -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($crate::add!(0 $(, 1!$k)*)), 
                |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                    Some(ref mut a) => a.as_mut_ptr(),
                                    None => $crate::unreachable_unchecked(),
                                };

                    $(
                        let k = $crate::transmute_copy(&$k);
                        map_ptr.add(actual_len.0).write(k);
                        actual_len.0 += 1;
                    )*

                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name()
        }
    };

    ( $( $k:expr ),*) => {
        {
            fn conflictless_large_name<T>(arr: [T; $crate::add!(0 $(, 1!$k)*)]) -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($crate::add!(0 $(, 1!$k)*)), 
                |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                    Some(ref mut a) => a.as_mut_ptr(),
                                    None => $crate::unreachable_unchecked(),
                                };

                    let arr = $crate::DontDropOpt::new(arr);
                    let arr_ptr = match *arr {
                        Some(ref e) => e.as_ptr(),
                        None => unsafe { $crate::unreachable_unchecked() }, 
                    };

                    map_ptr.write(arr_ptr.read());
                    actual_len.0 += 1;
                    
                    $crate::expansion_bucle!(
                        map_ptr.add(actual_len.0).write(arr_ptr.add(actual_len.0).read());
                        actual_len.0 += 1; => 0 $( + 1!$k)* - 1
                    );

                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name([$( $k ),*])
        }
    };

    (for $map:expr, ins $e:literal; $n:literal) => {
        {
            fn conflictless_large_name<'a, T>(mut mutable_ref: &'a mut Vector<T>) -> &'a mut Vector<T> {
                let mut offset = $crate::DontDrop(mutable_ref.len());
                let actual_ptr = &offset.0 as *const usize;
                mutable_ref.reserve($n);
                let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match mutable_ref.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    let t = $crate::transmute_copy;

                    $crate::expansion_bucle!(let e: T = t(&$e); map_ptr.add(offset.0).write(e);
                    offset.0 += 1; => $n);
                }

                let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(offset.0)};
                vec1
            }

            conflictless_large_name($map)
        }
    };

    (for $map:expr, ins $e:expr; $n:literal) => {
        {
            fn conflictless_large_name<'a, T: Clone>(mut mutable_ref: &'a mut Vector<T>, e: T) -> &'a mut Vector<T> {
                let mut offset = $crate::DontDrop(mutable_ref.len());
                let actual_ptr = &offset.0 as *const usize;
                mutable_ref.reserve($n);
                let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match mutable_ref.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    $crate::expansion_bucle!(map_ptr.add(offset.0).write(e.clone()); offset.0 += 1; => $n - 1);

                    map_ptr.add(offset.0).write(e);
                    offset.0 += 1;
                }

                let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(offset.0)};
                vec1
            }

            conflictless_large_name($map, $e)
        }
    };

    ( $e:literal; $n:literal) => {
        {
            fn conflictless_large_name<T>() -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($n), |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    let t = $crate::transmute_copy;

                    let e: T = t(&$e);
                    map_ptr.write(e); 
                    actual_len.0 += 1;

                    $crate::expansion_bucle!(let e: T = t(&$e); map_ptr.add(actual_len.0).write(e); 
                    actual_len.0 += 1; => $n - 1);
                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name()
        }
    };

    ( $e:expr; $n:literal) => {
        {
            fn conflictless_large_name<T: Clone>(e: T) -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($n), |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {   
                        Some(ref mut a) => a.as_mut_ptr(),
                        None => $crate::unreachable_unchecked(),
                    };

                    map_ptr.write(e.clone()); 
                    actual_len.0 += 1;

                    $crate::expansion_bucle!(map_ptr.add(actual_len.0).write(e.clone()); 
                    actual_len.0 += 1; => $n - 2);

                    map_ptr.add(actual_len.0).write(e); 
                    actual_len.0 += 1;
                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name($e)
        }
    };

    ( $e:literal; $n:expr) => {
        {
            fn conflictless_large_name<T>(n: usize) -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity(n), |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    let t = $crate::transmute_copy;
                    let e: T = t(&$e); 
                    map_ptr.write(e);
                    actual_len.0 += 1;

                    for _ in 1..n {
                        let e: T = t(&$e); map_ptr.add(actual_len.0).write(e);actual_len.0 += 1;
                    }
                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name($n)
        }
    };

    ( $e:expr; $n:expr) => {
        {
            fn conflictless_large_name<T: Clone>(e: T, n: usize) -> Vector<T> {
                let mut actual_len = $crate::DontDrop(0);
                let actual_ptr = &actual_len.0 as *const usize;
                let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity(n), |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match map.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };
       
                    map_ptr.write(e.clone());
                    actual_len.0 += 1; 

                    for _ in 2..n {
                       map_ptr.add(actual_len.0).write(e.clone());
                       actual_len.0 += 1;
                    }

                    map_ptr.add(actual_len.0).write(e);
                    actual_len.0 += 1;
                }

                let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(actual_len.0) };
                vec1
            }

            conflictless_large_name($e, $n)
        }
    };

    (for $map:expr, ins $e:literal; $n:expr) => {
        {
            fn conflictless_large_name<'a, T>(mut mutable_ref: &'a mut Vector<T>, n: usize) -> &'a mut Vector<T> {
                let mut offset = $crate::DontDrop(mutable_ref.len());
                let actual_ptr = &offset.0 as *const usize;
                mutable_ref.reserve(n);
                let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match mutable_ref.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    let t = $crate::transmute_copy;

                    for _ in 1..n {
                        let e: T = t(&$e); 
                        map_ptr.add(offset.0).write(e);
                        offset.0 += 1;
                    }
                }

                let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(offset.0)};
                vec1
            }

            conflictless_large_name($map, $n)
        }
    };

    (for $map:expr, ins $e:expr; $n:expr) => {
        {
            fn conflictless_large_name<'a, T: Clone>(mut mutable_ref: &'a mut Vector<T>, e: T, n: usize) -> &'a mut Vector<T> {
                let mut offset = $crate::DontDrop(mutable_ref.len());
                let actual_ptr = &offset.0 as *const usize;
                mutable_ref.reserve(n);
                let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe { v.set_len(actual_ptr.read()) });

                unsafe {
                    let map_ptr: *mut T = match mutable_ref.value {
                                            Some(ref mut a) => a.as_mut_ptr(),
                                            None => $crate::unreachable_unchecked(),
                                        };

                    for _ in 1..n {
                        map_ptr.add(offset.0).write(e.clone());
                        offset.0 += 1;
                    }
                    
                    map_ptr.add(offset.0).write(e);
                    offset.0 += 1;
                }

                let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
                unsafe { vec1.set_len(offset.0)};
                vec1
            }

            conflictless_large_name($map, $e, $n)
        }
    };

    ( $( $k:tt ,)*) => {
        $crate::vector!($( $k ),*)
    };
}


/// Construct an owned slice with the same syntax as arrays,of type OwnedSlice<T>.
/// 
/// In general,modify a vector and then obtain a owned slice thought into_boxed_slice is much better
/// optimal. Use this when,e.g,other constructor did exactly that and you want to define your own for
/// a particular data type or when this method is not available,via an expansion bucle.
/// 
/// Also note that,for non-literal inputs,the performance may be similar or even worse than
/// `[foo, bar, baz].to_vec().into_boxed_slice()`.
/// 
/// # Examples
/// 
/// ```
/// #![feature(new_uninit, type_ascription, proc_macro_hygiene)] 
/// // the second is for convenience in this example
/// use col_macros::{vector, own_slice};
/// use col_macros::types::{Vector, OwnedSlice}; // OwnedSlice<T> = Box<[T]>
/// 
/// let one: usize = 1;
/// assert_eq!(vector![1, 2, 3].into_boxed_slice(): OwnedSlice<usize>, own_slice![1, 2, 3]);
/// assert_eq!(vector![1, 2, 3].into_boxed_slice(): OwnedSlice<usize>, own_slice![one, 2, 3]);
/// 
/// assert_eq!(vector![1; 8].into_boxed_slice(): OwnedSlice<usize>, own_slice![one; 8]);
/// 
/// assert_eq!(vector![one; 8].into_boxed_slice(): OwnedSlice<usize>, own_slice![1; 8]);
/// assert_eq!(vector![1].into_boxed_slice(): OwnedSlice<usize>, own_slice![1; one]);
/// ```
/// 
/// This optional feature is nightly-only due to the use of the associated function [`Box::new_uninit_slice`]
/// of the [`new_uninit`] feature flag.
#[cfg(feature = "owned_slice")]
#[macro_export]
macro_rules! own_slice {
    ($( $a:literal ),*) => {
        unsafe {
            unsafe fn conflictless_large_name<T>() -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice($crate::add!(0 $(, 1!$a)* ));

                let mut index = 0;
            
                $(
                    let a = $crate::transmute_copy(&$a);
                    boxed.get_unchecked_mut(index).as_mut_ptr().write(a);
                    index += 1;
                )*
            
                $crate::transmute(boxed)
            }
            
            conflictless_large_name()
        }
    };

    ($( $a:expr ),*) => {
        unsafe {
            unsafe fn conflictless_large_name<T>(arr: [T; $crate::add!(0 $(, 1!$a)*) ]) -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice($crate::add!(0 $(, 1!$a)*));

                let arr = $crate::DontDropOpt::new(arr);
                let arr_ptr = match *arr {
                    Some(ref a) => a.as_ptr(),
                    None => $crate::unreachable_unchecked(), 
                };
            
                $crate::expansion_bucle_counted!(
                    boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(arr_ptr.add(rep_count).read());
                    => 0 $(+ 1!$a)*
                );
            
                $crate::transmute(boxed)
            }
            
            conflictless_large_name([$( $a ),*])
        }
    };

    ($( $a:tt, )*) => {
        own_slice!($( $a ,)*)
    };

    ($a:literal; $n:literal) => {
        unsafe {
            unsafe fn conflictless_large_name<T: Clone>() -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice($n);

                let t = $crate::transmute_copy;
            
                $crate::expansion_bucle_counted!(
                    let a = t(&$a);
                    boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(a); => $n - 1);

                let a = t(&$a);
                boxed.get_unchecked_mut($crate::sub!($n, 1)).as_mut_ptr().write(a);
            
                $crate::transmute(boxed)
            }
            
           conflictless_large_name() 
        }
    };

    
    ($a:literal; $n:expr) => {
        unsafe {
            unsafe fn conflictless_large_name<T>(a: T, n: usize) -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice(n);
            
                for i in 0..n {
                    let a = $crate::transmute_copy(&$a);
                    boxed.get_unchecked_mut(i).as_mut_ptr().write(a);
                }
            
                $crate::transmute(boxed)
            }
            
            conflictless_large_name($a, $n)
        }
    };

    ($a:expr; $n:literal) => {
        unsafe {
            unsafe fn conflictless_large_name<T: Clone>(a: T) -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice($n);
            
                $crate::expansion_bucle_counted!(
                    boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(a.clone()); => $n - 1);

                boxed.get_unchecked_mut($crate::sub!($n, 1)).as_mut_ptr().write(a);
            
                $crate::transmute(boxed)
            }
            
            conflictless_large_name($a)
        }
    };

    ($a:expr; $n:expr) => {
        unsafe {
            unsafe fn conflictless_large_name<T: Clone>(a: T, n: usize) -> OwnedSlice<T> {
                let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = Box::new_uninit_slice(n);
            
                for i in 1..n {
                    boxed.get_unchecked_mut(i).as_mut_ptr().write(a.clone());
                }

                boxed.get_unchecked_mut(0).as_mut_ptr().write(a);
            
                $crate::transmute(boxed)
            }
            
            conflictless_large_name($a, $n)
        }
    };
}

/// Construct a double-ended queue of type Deque\<T\> which can be and is an alias to VecDeque<T> in the types module.
///
/// It does so by simply creating an array from the elements,set the capacity of the vec at they length,read each entry into
/// and [mem::forget](https://doc.rust-lang.org/std/mem/fn.forget.html) the array.
///  
/// Collections with a capacity,the push_back and push_front methods,are accepted LinkedList not.  
///
/// # Examples
///
/// ```
/// use col_macros::vec_deque;
/// use col_macros::types::Deque;
///
/// let mut vec = vec_deque![1, 2, 3 => 4, 5, 6];
/// let mut vec2 = {
///     let mut vec1 = Deque::new();
///     
///     vec1.push_front(1);
///     vec1.push_front(2);
///     vec1.push_front(3);
///     
///     vec1.push_back(4);
///     vec1.push_back(5);
///     vec1.push_back(6);
///     vec1
/// };
///
/// assert_eq!(vec, vec2);
/// ```
#[macro_export]
macro_rules! vec_deque {
    ($($front:expr),* => $($back:expr),*) => {
    {
        let arr_front = $crate::DontDropOpt::new([$($front),*]);
        let arr_back = $crate::DontDropOpt::new([$($back),*]);
        let arr_front_len = arr_front.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len();
        let arr_back_len = arr_back.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len();
        let mut temp_vec_deque = <Deque<_>>::with_capacity(arr_front_len+arr_back_len);

        unsafe {
            let arr_front_ptr = arr_front.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();
            let arr_back_ptr = arr_back.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();
            temp_vec_deque.push_front(arr_front_ptr.read());
            temp_vec_deque.push_back(arr_back_ptr.read());

            for i in 1..arr_front_len {
                temp_vec_deque.push_front(arr_front_ptr.add(i).read());
            }

            for i in 1..arr_back_len {
                temp_vec_deque.push_back(arr_back_ptr.add(i).read());
            }
        }

        temp_vec_deque
    }
    };

    ($e:expr; $n:expr) => {
    {
        let arr_back = $crate::DontDropOpt([$e; $n]);
        let arr_back_len = arr_back.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len();
        let mut temp_vec_deque = <Deque<_>>::with_capacity(arr_back_len);

        unsafe {
            let arr_back_ptr = arr_back.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();
            temp_vec_deque.push_back(arr_back_ptr.read());

            for i in 1..arr_back_len {
                temp_vec_deque.push_front(arr_front_ptr.add(i).read());
            }
        }

        temp_vec_deque
    }
    };
}

/// Construct or update a map of type Map<K, V> which can be and is an alias to HashMap<K, V> in the types module.
///
/// It does so by simply creating an array from key-value tuples,set the capacity of the map at they length,read each tuple,insert the keys to values
/// and [mem::forget](https://doc.rust-lang.org/std/mem/fn.forget.html) the array.
///
/// Maps with a capacity and the insert method are accepted,BTreeMap not.  
///
/// # Examples
///
/// ```
/// use col_macros::hash_map;
/// use col_macros::types::Map;
///
/// let mut hash = hash_map!["key1" => 1, "key2" => 2];
/// let mut hash2 = {
///     let mut temp = Map::with_capacity(2);
///     temp.insert("key1", 1);
///     temp.insert("key2", 2);
///     temp
/// };
///
/// assert_eq!(hash["key1"], 1);
/// assert_eq!(hash["key2"], 2);
///
/// assert_eq!(hash2["key1"], 1);
/// assert_eq!(hash2["key2"], 2);
///
/// hash_map![for &mut hash, ins "key3" => 3, "key4" => 4];
///
/// assert_eq!(hash["key3"], 3);
/// assert_eq!(hash["key4"], 4);
/// ```
#[macro_export]
macro_rules! hash_map {
    (for $map:expr, ins $( $k:expr => $v:expr ),*) => {
        {
            let arr = $crate::DontDropOpt::new([$( ($k, $v) ),*]);
            let mut map = $map;
            map.reserve(arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len());

            unsafe {
                let arr_ptr = arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();

                for i in 0..arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len() {
                    let tuple = arr_ptr.add(i).read(); 
                    map.insert(tuple.0, tuple.1);         
                }

            }

            map
        }
    };

    (for $map:tt, ins $( $k:tt => $v:tt ,)*) => {
        $crate::hash_map!(for $map; $( $k => $v ),*)
    };

    ( $( $k:expr => $v:expr ),*) => {
        {
            let arr = $crate::DontDropOpt::new([$( ($k, $v) ),*]);
            let mut map = <Map<_, _>>::with_capacity(arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len());

            unsafe {
                let arr_ptr = arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();

                for i in 0..arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len() { 
                    let tuple = arr_ptr.add(i).read(); // this will never be UB 'cause the first value is zero
                    map.insert(tuple.0, tuple.1);                // and the end is arr.len-1
               }

            }

            map
        }
    };

    ( $( $k:tt => $v:tt ,)*) => {
        $crate::hash_map!($( $k => $v ),*)
    };
}

/// Construct or update a set of type Set\<K\> which can be and is an alias to HashSet<K> in the types module.
///
/// It does so by simply creating an array from the keys,set the capacity of the set at they length,read and insert the keys into
/// and [mem::forget](https://doc.rust-lang.org/std/mem/fn.forget.html) the array.
///
/// Collections with a capacity and the insert method are accepted,BTreeSet not.  
///
/// # Examples
///
/// ```
/// use col_macros::hash_set;
/// use col_macros::types::Set;
///
/// let mut hash = hash_set!["key1", "key2"];
///
/// assert!(hash.contains("key1"));
/// assert!(hash.contains("key2"));
///
/// hash = hash_set![for hash, ins "key3", "key4"];
///
/// assert!(hash.contains("key3"));
/// assert!(hash.contains("key4"));
/// ```
#[macro_export]
macro_rules! hash_set {
    (for $map:expr, ins $( $k:expr ),*) => {
        {
            let arr = $crate::DontDropOpt::new([$($k),*]);
            let mut map = $map;
            map.reserve(arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len());

            unsafe {
               let arr_ptr = arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();

                for i in 0..arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len() {  // this will never be UB 'cause the first value is zero
                    map.insert(arr_ptr.add(i).read()); // and the end is arr.len-1
                }

            }

            map
        }
    };

    (for $map:tt, ins $( $k:tt ,)*) => {
        hash_set!(for $map, ins $( $k ),*)
    };

    ( $( $k:expr ),*) => {
        {
            let arr = $crate::DontDropOpt::new([$($k),*]);
            let mut map = <Set<_>>::with_capacity(arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len());

            unsafe {
                let arr_ptr = arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().as_ptr();

                for i in 0..arr.unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() }).as_ref().len() { 
                    map.insert(arr_ptr.add(i).read()); 
                }

            }

            map
        }
    };

    ( $( $k:tt => $v:tt ,)*) => {
        hash_set!($( $k ),*)
    };
}

/// Construct or update a map of type BTMap<K, V> which can be and is an alias to BTreeMap<K, V> in the types module.
///
/// All types of maps are accepted but if a map has capacity and their respective methods, [hash_map!](./macro.hash_map.html) is preferred.  
///
/// # Examples
///
/// ```
/// use col_macros::btree_map;
/// use col_macros::types::BTMap;
///
/// let mut hash = btree_map!["key1" => 1, "key2" => 2];
/// let mut hash2 = {
///     let mut temp = BTMap::new();
///     temp.insert("key1", 1);
///     temp.insert("key2", 2);
///     temp
/// };
///
/// assert_eq!(hash["key1"], 1);
/// assert_eq!(hash["key2"], 2);
///
/// assert_eq!(hash2["key1"], 1);
/// assert_eq!(hash2["key2"], 2);
///
/// btree_map![for &mut hash, ins "key3" => 3, "key4" => 4];
///
/// assert_eq!(hash["key3"], 3);
/// assert_eq!(hash["key4"], 4);
/// ```
#[macro_export]
macro_rules! btree_map {
    (for $map:expr, ins $( $k:expr => $v:expr ),*) => {
        {
            let mut map = $map;
            $(map.insert($k, $v);)*
            map
        }
    };

    (for $map:tt, ins $( $k:tt => $v:tt ,)*) => {
        btree_map!(for $map, ins $( $k => $v ),*)
    };

    ( $( $k:expr => $v:expr ),*) => {
        {
            let mut map = <BTMap<_, _>>::new();
            $(map.insert($k, $v);)*
            map
        }
    };

    ( $( $k:tt => $v:tt ,)*) => {
        btree_map!($( $k => $v ),*)
    };
}

/// Construct or update a set of type BTSet\<K\> which can be and is an alias to BTreeSet<K> in the types module.
///
/// All sets are accepted but if a set implements capacity and their respective methods [hash_set!](./macro.hash_set.html) is preferred.  
///
/// # Examples
///
/// ```
/// use col_macros::btree_set;
/// use col_macros::types::BTSet;
///
/// let mut hash = btree_set!["key1", "key2"];
///
/// assert!(hash.contains("key1"));
/// assert!(hash.contains("key2"));
///
/// btree_set![for &mut hash, ins "key3", "key4"];
///
/// assert!(hash.contains("key3"));
/// assert!(hash.contains("key4"));
/// ```
#[macro_export]
macro_rules! btree_set {
    (for $map:expr, ins $( $k:expr ),*) => {
        {
            let mut map = $map;
            $(map.insert($k);)*
            map
        }
    };

    (for $map:tt, ins $( $k:tt ,)*) => {
        $crate::btree_set!(for $map, ins $( $k ),*)
    };

    ( $( $k:expr ),*) => {
        {
            let mut map = <BTSet<_>>::new();
            $(map.insert($k);)*
            map
        }
    };

    ( $( $k:tt ,)*) => {
        $crate::btree_set!($( $k ),*)
    };
}