1 // run-pass
2 #![allow(unused_must_use)]
main()3 fn main() {
4 if false { test(); }
5 }
6
test()7 fn test() {
8 let rx = Err::<Vec<usize>, u32>(1).into_future();
9
10 rx.map(|l: Vec<usize>| stream::iter(l.into_iter().map(|i| Ok(i))))
11 .flatten_stream()
12 .chunks(50)
13 .buffer_unordered(5);
14 }
15
16 use future::{Future, IntoFuture};
17 mod future {
18 use std::result;
19
20 use {stream, Stream};
21
22 pub trait Future {
23 type Item;
24 type Error;
25
map<F, U>(self, _: F) -> Map<Self, F> where F: FnOnce(Self::Item) -> U, Self: Sized,26 fn map<F, U>(self, _: F) -> Map<Self, F>
27 where F: FnOnce(Self::Item) -> U,
28 Self: Sized,
29 {
30 panic!()
31 }
32
flatten_stream(self) -> FlattenStream<Self> where <Self as Future>::Item: stream::Stream<Error=Self::Error>, Self: Sized33 fn flatten_stream(self) -> FlattenStream<Self>
34 where <Self as Future>::Item: stream::Stream<Error=Self::Error>,
35 Self: Sized
36 {
37 panic!()
38 }
39 }
40
41 pub trait IntoFuture {
42 type Future: Future<Item=Self::Item, Error=Self::Error>;
43 type Item;
44 type Error;
into_future(self) -> Self::Future45 fn into_future(self) -> Self::Future;
46 }
47
48 impl<F: Future> IntoFuture for F {
49 type Future = F;
50 type Item = F::Item;
51 type Error = F::Error;
52
into_future(self) -> F53 fn into_future(self) -> F {
54 panic!()
55 }
56 }
57
58 impl<T, E> IntoFuture for result::Result<T, E> {
59 type Future = FutureResult<T, E>;
60 type Item = T;
61 type Error = E;
62
into_future(self) -> FutureResult<T, E>63 fn into_future(self) -> FutureResult<T, E> {
64 panic!()
65 }
66 }
67
68 pub struct Map<A, F> {
69 _a: (A, F),
70 }
71
72 impl<U, A, F> Future for Map<A, F>
73 where A: Future,
74 F: FnOnce(A::Item) -> U,
75 {
76 type Item = U;
77 type Error = A::Error;
78 }
79
80 pub struct FlattenStream<F> {
81 _f: F,
82 }
83
84 impl<F> Stream for FlattenStream<F>
85 where F: Future,
86 <F as Future>::Item: Stream<Error=F::Error>,
87 {
88 type Item = <F::Item as Stream>::Item;
89 type Error = <F::Item as Stream>::Error;
90 }
91
92 pub struct FutureResult<T, E> {
93 _inner: (T, E),
94 }
95
96 impl<T, E> Future for FutureResult<T, E> {
97 type Item = T;
98 type Error = E;
99 }
100 }
101
102 mod stream {
103 use IntoFuture;
104
105 pub trait Stream {
106 type Item;
107 type Error;
108
buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where Self::Item: IntoFuture<Error = <Self as Stream>::Error>, Self: Sized109 fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self>
110 where Self::Item: IntoFuture<Error = <Self as Stream>::Error>,
111 Self: Sized
112 {
113 new(self, amt)
114 }
115
chunks(self, _capacity: usize) -> Chunks<Self> where Self: Sized116 fn chunks(self, _capacity: usize) -> Chunks<Self>
117 where Self: Sized
118 {
119 panic!()
120 }
121 }
122
123 pub struct IterStream<I> {
124 _iter: I,
125 }
126
iter<J, T, E>(_: J) -> IterStream<J::IntoIter> where J: IntoIterator<Item=Result<T, E>>,127 pub fn iter<J, T, E>(_: J) -> IterStream<J::IntoIter>
128 where J: IntoIterator<Item=Result<T, E>>,
129 {
130 panic!()
131 }
132
133 impl<I, T, E> Stream for IterStream<I>
134 where I: Iterator<Item=Result<T, E>>,
135 {
136 type Item = T;
137 type Error = E;
138 }
139
140 pub struct Chunks<S> {
141 _stream: S
142 }
143
144 impl<S> Stream for Chunks<S>
145 where S: Stream
146 {
147 type Item = Result<Vec<<S as Stream>::Item>, u32>;
148 type Error = <S as Stream>::Error;
149 }
150
151 pub struct BufferUnordered<S> {
152 _stream: S,
153 }
154
155 enum Slot<T> {
156 Next(usize),
157 _Data { _a: T },
158 }
159
new<S>(_s: S, _amt: usize) -> BufferUnordered<S> where S: Stream, S::Item: IntoFuture<Error=<S as Stream>::Error>,160 fn new<S>(_s: S, _amt: usize) -> BufferUnordered<S>
161 where S: Stream,
162 S::Item: IntoFuture<Error=<S as Stream>::Error>,
163 {
164 (0..0).map(|_| {
165 Slot::Next::<<S::Item as IntoFuture>::Future>(1)
166 }).collect::<Vec<_>>();
167 panic!()
168 }
169
170 impl<S> Stream for BufferUnordered<S>
171 where S: Stream,
172 S::Item: IntoFuture<Error=<S as Stream>::Error>,
173 {
174 type Item = <S::Item as IntoFuture>::Item;
175 type Error = <S as Stream>::Error;
176 }
177 }
178 use stream::Stream;
179