asynciter 0.1.0

use std::{
    collections::{BTreeMap, HashMap, HashSet, VecDeque},
    future::Future,
    hash::{BuildHasher, Hash},
};

use crate::AsyncIterator;

pub trait FromAsyncIterator<A> {
    // This is a compiler bug. See issue #113538.
    #[allow(opaque_hidden_inferred_bound)]
    fn from_iter<T>(iter: T) -> impl Future<Output = Self>
    where
        T: AsyncIterator<Item = A>;
}

impl<A> FromAsyncIterator<A> for Vec<A> {
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = A>,
    {
        let mut vec: Vec<A> = Vec::with_capacity(iter.size_hint().0);
        while let Some(item) = iter.next().await {
            vec.push(item);
        }

        vec
    }
}

impl<A> FromAsyncIterator<A> for VecDeque<A> {
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = A>,
    {
        let mut vec: VecDeque<A> = VecDeque::with_capacity(iter.size_hint().0);
        while let Some(item) = iter.next().await {
            vec.push_back(item);
        }

        vec
    }
}

impl<K, V, S> FromAsyncIterator<(K, V)> for HashMap<K, V, S>
where
    K: Eq + Hash,
    S: BuildHasher + Default,
{
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = (K, V)>,
    {
        let mut map: HashMap<K, V, S> = HashMap::with_hasher(Default::default());
        while let Some((k, v)) = iter.next().await {
            map.insert(k, v);
        }

        map
    }
}

impl<K, V> FromAsyncIterator<(K, V)> for BTreeMap<K, V>
where
    K: Ord,
{
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = (K, V)>,
    {
        let mut map: BTreeMap<K, V> = BTreeMap::new();
        while let Some((k, v)) = iter.next().await {
            map.insert(k, v);
        }

        map
    }
}

impl FromAsyncIterator<String> for String {
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = String>,
    {
        match iter.next().await {
            None => String::new(),
            Some(mut buf) => {
                while let Some(n) = iter.next().await {
                    buf.push_str(&n)
                }
                buf
            }
        }
    }
}

impl FromAsyncIterator<char> for String {
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = char>,
    {
        let mut buf = String::new();
        while let Some(n) = iter.next().await {
            buf.push(n)
        }

        buf
    }
}

impl<'a> FromAsyncIterator<&'a str> for String {
    async fn from_iter<T>(mut iter: T) -> Self
    where
        T: AsyncIterator<Item = &'a str>,
    {
        let mut buf = String::new();
        while let Some(s) = iter.next().await {
            buf.push_str(s)
        }

        buf
    }
}

impl<T, S> FromAsyncIterator<T> for HashSet<T, S>
where
    T: Eq + Hash,
    S: BuildHasher + Default,
{
    async fn from_iter<I>(mut iter: I) -> Self
    where
        I: AsyncIterator<Item = T>,
    {
        let mut set = HashSet::with_hasher(Default::default());
        while let Some(v) = iter.next().await {
            set.insert(v);
        }

        set
    }
}