#![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 encountered_error = None;
        let collection =
            iterable
                .into_iter()
                .filter_map(|try_item| match try_item.into_result() {
                    | Ok(item) => Some(item),
                    | Err(error) => {
                        encountered_error = Some(error);
                        None
                    },
                })
                .collect()
        ;
        if let Some(error) = encountered_error {
            R::from_error(error)
        } else {
            R::from_ok(collection)
        }
    }
}

#[derive(Debug)]
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 = vec![MySome(42), MyNone];

    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>,
        ;
    }
}