#![feature(try_trait)]
use ::core::ops::Try;

impl<TryItem, R> iter::FromIterator<TryItem> for R
where
    TryItem : Try,
    R : Try<Error = <TryItem as Try>::Error>,
    <R as Try>::Ok : ::core::iter::FromIterator<<TryItem as Try>::Ok>,
{
    fn from_iter<Iterable> (iterable: Iterable) -> Self
    where
        Iterable : IntoIterator<Item = TryItem>,
    {
        let mut iterator = iterable.into_iter();
        let mut vec = Vec::with_capacity(match iterator.size_hint() {
            | (_, Some(upper)) => upper,
            | (lower, _) => lower,
        });
        loop {
            match iterator.next().map(Try::into_result) {
                | Some(Ok(item)) => vec.push(item),
                | Some(Err(error)) => return R::from_error(error),
                | None => return R::from_ok(vec.into_iter().collect()),
            }
        }
    }
}

#[derive(Debug, Clone, Copy)]
enum MyOption<T> {
    MyNone,
    MySome(T),
}
use self::MyOption::*;

impl<T> Try for MyOption<T> {
    type Ok = T;
    type Error = ();

    fn into_result (self) -> Result<T, ()>
    {
        if let MySome(inner) = self {
            Ok(inner)
        } else {
            Err(())
        }
    }

    fn from_ok (inner: T) -> Self
    {
        MySome(inner)
    }

    fn from_error ((): ()) -> Self
    {
        MyNone
    }
}

fn main ()
{
    use iter::FromIterator;

    let elems =
        [MySome(42), MyNone, MySome(27)]
            .iter()
            .map(|&x| {
                eprintln!("> {:?}", x);
                x
            })
    ;
    dbg!(
        <MyOption<Vec<i32>>>::from_iter(elems)
    );
}

mod iter {
    pub
    trait FromIterator<A> {
        fn from_iter<T> (iter: T) -> Self
        where
            T : IntoIterator<Item = A>,
        ;
    }
}