fizzbuzz.rs

#![feature(prelude_import)]
#![feature(generators, generator_trait, try_trait)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;

fn fizz_buzz() -> (impl Iterator<Item = String>) {
    let __ret = || {
        {
            for x in 1..101 {
                match (x % 3 == 0, x % 5 == 0) {
                    (true, true) => yield String::from("FizzBuzz"),
                    (true, false) => yield String::from("Fizz"),
                    (false, true) => yield String::from("Buzz"),
                    (..) => yield x.to_string(),
                }
            }
        };

        #[allow(unreachable_code)]
        {
            return;
            yield

                        // yada yada yada

                        { { ::std::rt::begin_panic("explicit panic") } };
        }
    };

    #[allow(unreachable_code)]
    propane::__internal::GenIter(__ret)
}
fn main() {
    let mut fizz_buzz = fizz_buzz();
    {
        match (&&fizz_buzz.next().unwrap()[..], &"1") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"2") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"Fizz") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"4") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"Buzz") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"Fizz") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"7") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let mut fizz_buzz = fizz_buzz.skip(90);
    {
        match (&&fizz_buzz.next().unwrap()[..], &"98") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"Fizz") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    {
        match (&&fizz_buzz.next().unwrap()[..], &"Buzz") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    if !fizz_buzz.next().is_none() {
        {
            ::std::rt::begin_panic("assertion failed: fizz_buzz.next().is_none()")
        }
    };
}