#[test]
    fn test_vec_functor() {
        let e = Vec::<i32>::eval()
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| format!{"{:?}", i});

        // operation is constructed on the stack, so, typeof e is:
        // `functor<'_, VecKind, String,
        //         functor<'_, VecKind, i32, [closure@src/sandbox/lazy8.rs:377:18: 377:27],
        //                functor<'_, VecKind, i32, [closure@src/sandbox/lazy8.rs:376:18: 376:27],
        //                       Head<'_, VecKind, i32>>>>`
        assert_eq!(e.run(vec![1,2,3]), vec!["4".to_owned(), "8".to_owned(), "12".to_owned()]);
        assert_eq!(e.run(vec![3,2,1]),  vec!["12".to_owned(), "8".to_owned(), "4".to_owned()])
    }

// i know nothing about benchmarking so this probably sucks!
    #[bench]
    fn bench_vec_map_native(b: &mut Bencher) {
        b.iter(|| {
            let result = vec![1, 2, 3]
                .into_iter()
                .map(|i| i * 2)
                .map(|i| i * 2)
                .map(|i| format!("{:?}", i))
                .collect::<Vec<String>>();

            let result2 = vec![1, 2, 3]
                .into_iter()
                .map(|i| i * 2)
                .map(|i| i * 2)
                .map(|i| format!("{:?}", i))
                .collect::<Vec<String>>();

            assert_eq!(result, result2)
        });
    }

    #[bench]
    fn bench_vec_map_from_functor(b: &mut Bencher) {
        let h = Vec::<i32>::eval()
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| format!{"{:?}", i});

        b.iter(|| {
            let result = h.run(vec![1, 2, 3]);
            let result2 = h.run(vec![1, 2, 3]);
            assert_eq!(result, result2)
        })
    }

test sandbox::lazy8::tests::bench_vec_map_from_functor    ... bench:         857 ns/iter (+/- 80)
test sandbox::lazy8::tests::bench_vec_map_native          ... bench:         666 ns/iter (+/- 103)

impl<'d> Functor<'d, VecKind> for VecKind {
    /// If you use your imagination, you can pretend that this translates to:
    /// (F<A>, Fn(A) -> B) -> F<B>
    /// While it's pretty ugly, the type equation above is enforced.
    /// There's also some room for improvement here.
    ///
    /// In this encoding, "FA" represents our concrete HKT, Vec<A>.
    ///
    /// The return type is the ugliest bit: basically, the only way to build a deferred chain
    /// of polymorphic operations on the stack is by building a nested structure like so:
    /// Map {
    ///   op: closure@src...,
    ///   inner: Map {
    ///       op: closure@src...,
    ///       inner: Value(Some(1))
    ///
    /// The outermost map executes it's closure with the value of the output of it's inner Map, which
    /// executes it's closure with the output of _it's_ inner Map, and so forth. This is how futures and interators work.
    ///
    /// So anyhow, we basically have to pass our function and our FA into the output of our functor,
    /// so I'm basically just pretending this is boilerplate that you can ignore. However it's still
    /// an important and complicated part of the public api so it's really not ideal. OH well.
    fn map<F, A, B, FA>(fa: FA, f: F) -> functor<'d, VecKind, B, F, FA>
    where
        F: Fn(FA::Item) -> B,
        FA: Lifted<'d, Kind = VecKind, Item= A>,
    {
        functor {
            inner: fa,
            f: f,
            __marker_k: VecKind,
            __marker_b: PhantomData,
        }
    }
}

        let h = Vec::<i32>::eval()
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| i * 2)
            .map(|i| format!{"{:?}", i});
> time cargo test

DONT THREAD ON ME fucked around with this message at 04:35 on Jul 19, 2018

test sandbox::lazy8::tests::bench_vec_map_from_functor    ... bench:   2,231,253 ns/iter (+/- 40,062)
test sandbox::lazy8::tests::bench_vec_map_native          ... bench:   2,138,998 ns/iter (+/- 39,938)

test sandbox::lazy8::tests::bench_vec_map_from_functor_no_string_alloc    ... bench:      69,607 ns/iter (+/- 7,078)
test sandbox::lazy8::tests::bench_vec_map_native_no_string_alloc          ... bench:       7,118 ns/iter (+/- 546)

DONT THREAD ON ME fucked around with this message at 13:31 on Jul 19, 2018