amadeus-core 0.1.1

Harmonious distributed data analysis in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use serde::{Deserialize, Serialize};
use std::marker::PhantomData;

use super::{ConsumerMulti, DistributedIteratorMulti};

#[must_use]
pub struct Cloned<I, T, Source> {
	i: I,
	marker: PhantomData<fn(Source, T)>,
}
impl<I, T, Source> Cloned<I, T, Source> {
	pub(super) fn new(i: I) -> Self {
		Self {
			i,
			marker: PhantomData,
		}
	}
}

// impl<'a,I,T:'a> DistributedIterator for Cloned<I>
// where
// 	I: DistributedIterator<Item = &'a T>,
// 	T: Clone,
// {
// 	type Item = T;
// 	type Task = ClonedConsumer<I::Task>;
// 	fn size_hint(&self) -> (usize, Option<usize>) {
// 		self.i.size_hint()
// 	}
// 	fn next_task(&mut self) -> Option<Self::Task> {
// 		self.i.next_task().map(|task| ClonedConsumer { task })
// 	}
// }
// I'm a bit confused as to why this works and it isn't for Cloned<I, &'a Source, T>
// https://github.com/rust-lang/rust/issues/55731
// https://play.rust-lang.org/?version=nightly&mode=debug&edition=2015&gist=238651c4992913bcd62b68b4832fcd9a
// https://play.rust-lang.org/?version=nightly&mode=debug&edition=2015&gist=2f1da304878b050cc313c0279047b0fa
impl<'a, I, Source, T: 'a> DistributedIteratorMulti<&'a Source> for Cloned<I, T, Source>
where
	I: DistributedIteratorMulti<&'a Source, Item = &'a T>,
	T: Clone,
{
	type Item = T;
	type Task = ClonedConsumer<I::Task>;

	fn task(&self) -> Self::Task {
		let task = self.i.task();
		ClonedConsumer { task }
	}
}
#[derive(Serialize, Deserialize)]
pub struct ClonedConsumer<T> {
	task: T,
}
// impl<'a,C,T:'a> Consumer for ClonedConsumer<C>
// where
// 	C: Consumer<Item = &'a T>,
// 	T: Clone,
// {
// 	type Item = T;
// 	fn run(self, i: &mut impl FnMut(Self::Item) -> bool) -> bool {
// 		self.task.run(&mut |item| i(item.clone()))
// 	}
// }
impl<'a, C, Source, T: 'a> ConsumerMulti<&'a Source> for ClonedConsumer<C>
where
	C: ConsumerMulti<&'a Source, Item = &'a T>,
	T: Clone,
{
	type Item = T;

	fn run(&self, source: &'a Source, i: &mut impl FnMut(Self::Item) -> bool) -> bool {
		self.task.run(source, &mut |item| i(item.clone()))
	}
}