diff --git a/Cargo.toml b/Cargo.toml
index 323fded4..1c36e521 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name = "amadeus"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -14,7 +14,7 @@ parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common cr
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -35,14 +35,15 @@ json = ["amadeus-serde", "amadeus-derive/serde"]
 features = ["constellation", "aws", "commoncrawl", "parquet", "postgres", "csv", "json"]
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "amadeus-core" }
-amadeus-derive = { version = "=0.2.5", path = "amadeus-derive" }
-amadeus-types = { version = "=0.2.5", path = "amadeus-types" }
-amadeus-aws = { version = "=0.2.5", path = "amadeus-aws", optional = true }
-amadeus-commoncrawl = { version = "=0.2.5", path = "amadeus-commoncrawl", optional = true }
-amadeus-parquet = { version = "=0.2.5", path = "amadeus-parquet", optional = true }
-amadeus-postgres = { version = "=0.2.5", path = "amadeus-postgres", optional = true }
-amadeus-serde = { version = "=0.2.5", path = "amadeus-serde", optional = true }
+amadeus-core = { version = "=0.3.0", path = "amadeus-core" }
+amadeus-derive = { version = "=0.3.0", path = "amadeus-derive" }
+amadeus-types = { version = "=0.3.0", path = "amadeus-types" }
+amadeus-aws = { version = "=0.3.0", path = "amadeus-aws", optional = true }
+amadeus-commoncrawl = { version = "=0.3.0", path = "amadeus-commoncrawl", optional = true }
+amadeus-parquet = { version = "=0.3.0", path = "amadeus-parquet", optional = true }
+amadeus-postgres = { version = "=0.3.0", path = "amadeus-postgres", optional = true }
+amadeus-serde = { version = "=0.3.0", path = "amadeus-serde", optional = true }
+async-std = { version = "1.6", features = ["unstable"] }
 constellation-rs = { version = "0.1", default-features = false, optional = true }
 derive-new = "0.5"
 doc-comment = "0.3"
@@ -52,7 +53,7 @@ pin-project = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_closure = "0.2"
 serde_traitobject = { version = "0.2", optional = true }
-tokio = { version = "0.2", features = ["rt-threaded", "rt-util"] }
+tokio = { version = "0.2", features = ["rt-threaded", "rt-util", "blocking"] }
 
 [dev-dependencies]
 either = { version = "1.5", features = ["serde"] }
diff --git a/README.md b/README.md
index 4f85fd82..d1346372 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
 </p>
 
 <p align="center">
-    <a href="https://docs.rs/amadeus/0.2.3/amadeus/">📖 Docs</a> | <a href="https://constellation.rs/amadeus">🌐 Home</a> | <a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬 Chat</a>
+    <a href="https://docs.rs/amadeus">📖 Docs</a> | <a href="https://constellation.rs/amadeus">🌐 Home</a> | <a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬 Chat</a>
 </p>
 
 ## Amadeus provides:
@@ -50,7 +50,7 @@ We aim to create a community that is welcoming and helpful to anyone that is int
 
 Amadeus has deep, pluggable, integration with various file formats, databases and interfaces:
 
-| Data format | [`Source`](https://docs.rs/amadeus/0.2.5/amadeus/trait.Source.html) | [`Destination`](https://docs.rs/amadeus/0.2.5/amadeus/trait.Destination.html) |
+| Data format | [`Source`](https://docs.rs/amadeus/0.3/amadeus/trait.Source.html) | [`Destination`](https://docs.rs/amadeus/0.3/amadeus/trait.Destination.html) |
 |---|---|---|
 | CSV | ✔ | ✔ |
 | JSON | ✔ | ✔ |
@@ -149,7 +149,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
             let row = row.ok()?.into_group().ok()?;
             row.get("uri")?.clone().into_url().ok()
         })
-        .filter(|row| futures::future::ready(row.is_some()))
+        .filter(|row| row.is_some())
         .map(Option::unwrap)
         .most_frequent(&pool, 100, 0.99, 0.002)
         .await;
diff --git a/amadeus-aws/Cargo.toml b/amadeus-aws/Cargo.toml
index 5533cdc7..d8ff4a39 100644
--- a/amadeus-aws/Cargo.toml
+++ b/amadeus-aws/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-aws"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,8 +19,8 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
-amadeus-types = { version = "=0.2.5", path = "../amadeus-types" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
+amadeus-types = { version = "=0.3.0", path = "../amadeus-types" }
 async-compression = { version = "0.3.3", features = ["gzip", "futures-bufread"] }
 async-trait = "0.1"
 chrono = { version = "0.4", default-features = false }
@@ -35,6 +35,7 @@ serde_closure = "0.2"
 serde = { version = "1.0", features = ["derive"] }
 tokio = "0.2"
 url = { version = "2.1", features = ["serde"] }
+vec-utils = "0.2"
 
 # dependency of rusoto_core/hyper-tls/native-tls; ensure it's vendored to simplify cross-compilation
 [target.'cfg(not(any(target_os = "windows", target_os = "macos", target_os = "ios")))'.dependencies]
diff --git a/amadeus-aws/src/cloudfront.rs b/amadeus-aws/src/cloudfront.rs
index 32ffbe11..1dc18041 100644
--- a/amadeus-aws/src/cloudfront.rs
+++ b/amadeus-aws/src/cloudfront.rs
@@ -1,13 +1,16 @@
+#![allow(unused_qualifications)]
+
 use async_compression::futures::bufread::GzipDecoder;
 use chrono::{NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
 use futures::{future, io::BufReader, AsyncBufReadExt, FutureExt, StreamExt, TryStreamExt};
 use http::{Method, StatusCode};
 use rusoto_s3::{GetObjectRequest, Object, S3Client, S3};
 use serde::{Deserialize, Serialize};
-use serde_closure::*;
+use serde_closure::FnMut;
 use std::{
 	convert::identity, io::{self}, time::Duration
 };
+use vec_utils::VecExt;
 
 use amadeus_core::{
 	into_par_stream::IntoDistributedStream, par_stream::DistributedStream, util::{DistParStream, ResultExpandIter}, Source
@@ -39,9 +42,7 @@ impl Cloudfront {
 
 		let objects = list(&client, &bucket, &prefix)
 			.await?
-			.into_iter()
-			.map(|object: Object| object.key.unwrap())
-			.collect();
+			.map(|object: Object| object.key.unwrap());
 
 		Ok(Self {
 			region,
@@ -277,7 +278,7 @@ mod http_serde {
 	use http::{Method, StatusCode};
 	use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-	pub struct Serde<T>(T);
+	pub(crate) struct Serde<T>(T);
 
 	impl Serialize for Serde<&Method> {
 		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -325,14 +326,14 @@ mod http_serde {
 		}
 	}
 
-	pub fn serialize<T, S>(t: &T, serializer: S) -> Result<S::Ok, S::Error>
+	pub(crate) fn serialize<T, S>(t: &T, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		for<'a> Serde<&'a T>: Serialize,
 		S: Serializer,
 	{
 		Serde(t).serialize(serializer)
 	}
-	pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+	pub(crate) fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
 	where
 		Serde<T>: Deserialize<'de>,
 		D: Deserializer<'de>,
diff --git a/amadeus-aws/src/file.rs b/amadeus-aws/src/file.rs
index af3d77e2..c742c249 100644
--- a/amadeus-aws/src/file.rs
+++ b/amadeus-aws/src/file.rs
@@ -84,7 +84,7 @@ impl Directory for S3Directory {
 					|| (current_path.depth() > 0
 						&& current_path.last().unwrap() != path[current_path.depth() - 1])
 				{
-					current_path.pop().unwrap();
+					let _ = current_path.pop().unwrap();
 				}
 				while path.len() > current_path.depth() {
 					current_path.push(path[current_path.depth()]);
@@ -241,7 +241,7 @@ impl Page for S3Page {
 			let mut buf_ = vec![0; len].into_boxed_slice();
 			let mut buf = &mut *buf_;
 			let len: u64 = len.try_into().unwrap();
-			let mut pos = 0u64;
+			let mut pos = 0_u64;
 			let mut errors: usize = 0;
 			let end = offset + len - 1;
 			while !buf.is_empty() {
diff --git a/amadeus-aws/src/lib.rs b/amadeus-aws/src/lib.rs
index e5ab6df7..8ca9a86e 100644
--- a/amadeus-aws/src/lib.rs
+++ b/amadeus-aws/src/lib.rs
@@ -1,5 +1,34 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-aws/0.2.5")]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::source`](https://docs.rs/amadeus/0.3/amadeus/source/index.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-aws/0.3.0")]
 #![feature(type_alias_impl_trait)]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::if_not_else,
+	clippy::too_many_lines,
+	clippy::must_use_candidate,
+	clippy::type_repetition_in_bounds,
+	clippy::filter_map,
+	clippy::missing_errors_doc
+)]
+#![deny(unsafe_code)]
 
 mod cloudfront;
 mod file;
@@ -144,7 +173,7 @@ pub enum AwsError {
 	NoSuchBucket(String),
 	NoSuchKey(String),
 	HttpDispatch(rusoto_core::request::HttpDispatchError),
-	Credentials(rusoto_credential::CredentialsError),
+	Credentials(CredentialsError),
 	Validation(String),
 	ParseError(String),
 	Unknown(rusoto_core::request::BufferedHttpResponse),
@@ -156,8 +185,8 @@ impl Clone for AwsError {
 			Self::NoSuchBucket(err) => Self::NoSuchBucket(err.clone()),
 			Self::NoSuchKey(err) => Self::NoSuchKey(err.clone()),
 			Self::HttpDispatch(err) => Self::HttpDispatch(err.clone()),
-			Self::Credentials(rusoto_credential::CredentialsError { message }) => {
-				Self::Credentials(rusoto_credential::CredentialsError {
+			Self::Credentials(CredentialsError { message }) => {
+				Self::Credentials(CredentialsError {
 					message: message.clone(),
 				})
 			}
@@ -179,12 +208,12 @@ impl Clone for AwsError {
 impl PartialEq for AwsError {
 	fn eq(&self, other: &Self) -> bool {
 		match (self, other) {
-			(Self::NoSuchBucket(a), Self::NoSuchBucket(b)) => a == b,
-			(Self::NoSuchKey(a), Self::NoSuchKey(b)) => a == b,
+			(Self::NoSuchBucket(a), Self::NoSuchBucket(b))
+			| (Self::NoSuchKey(a), Self::NoSuchKey(b))
+			| (Self::Validation(a), Self::Validation(b))
+			| (Self::ParseError(a), Self::ParseError(b)) => a == b,
 			(Self::HttpDispatch(a), Self::HttpDispatch(b)) => a == b,
 			(Self::Credentials(a), Self::Credentials(b)) => a == b,
-			(Self::Validation(a), Self::Validation(b)) => a == b,
-			(Self::ParseError(a), Self::ParseError(b)) => a == b,
 			(Self::Unknown(a), Self::Unknown(b)) => a == b,
 			(Self::Io(a), Self::Io(b)) => a == b,
 			_ => false,
@@ -195,12 +224,12 @@ impl error::Error for AwsError {}
 impl Display for AwsError {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		match self {
-			Self::NoSuchBucket(err) => err.fmt(f),
-			Self::NoSuchKey(err) => err.fmt(f),
+			Self::NoSuchBucket(err)
+			| Self::NoSuchKey(err)
+			| Self::Validation(err)
+			| Self::ParseError(err) => err.fmt(f),
 			Self::HttpDispatch(err) => err.fmt(f),
 			Self::Credentials(err) => err.fmt(f),
-			Self::Validation(err) => err.fmt(f),
-			Self::ParseError(err) => err.fmt(f),
 			Self::Unknown(err) => fmt::Debug::fmt(err, f),
 			Self::Io(err) => err.fmt(f),
 		}
diff --git a/amadeus-commoncrawl/Cargo.toml b/amadeus-commoncrawl/Cargo.toml
index f1061287..cb1aad0b 100644
--- a/amadeus-commoncrawl/Cargo.toml
+++ b/amadeus-commoncrawl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-commoncrawl"
-version = "0.2.5"
+version = "0.3.0"
 license = "MIT OR Apache-2.0"
 authors = ["Stephen Becker IV <github@deathbyescalator.com>", "Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,8 +19,8 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
-amadeus-types = { version = "=0.2.5", path = "../amadeus-types" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
+amadeus-types = { version = "=0.3.0", path = "../amadeus-types" }
 async-compression = { version = "0.3.3", features = ["gzip", "futures-bufread"] }
 futures = "0.3"
 nom = "4.2.3"
diff --git a/amadeus-commoncrawl/src/commoncrawl.rs b/amadeus-commoncrawl/src/commoncrawl.rs
index 299da35d..07e26857 100644
--- a/amadeus-commoncrawl/src/commoncrawl.rs
+++ b/amadeus-commoncrawl/src/commoncrawl.rs
@@ -14,7 +14,7 @@ const CHOMP: usize = 2 << 13; // 8 KiB
 
 #[pin_project]
 #[derive(Clone, Debug)]
-pub struct WarcParser<I> {
+pub(crate) struct WarcParser<I> {
 	#[pin]
 	input: I,
 	state: WarcParserState,
@@ -30,7 +30,7 @@ enum WarcParserState {
 	Done,
 }
 impl<I> WarcParser<I> {
-	pub fn new(input: I) -> WarcParser<I> {
+	pub(crate) fn new(input: I) -> WarcParser<I> {
 		WarcParser {
 			input,
 			state: WarcParserState::Info,
@@ -43,7 +43,7 @@ impl<I> WarcParser<I>
 where
 	I: Read,
 {
-	pub fn next_borrowed(&mut self) -> Result<Option<Webpage<'_>>, io::Error> {
+	pub(crate) fn next_borrowed(&mut self) -> Result<Option<Webpage<'_>>, io::Error> {
 		if let WarcParserState::Done = self.state {
 			return Ok(None);
 		}
@@ -68,7 +68,7 @@ where
 			}
 
 			loop {
-				self.res.splice(..self.offset, iter::empty());
+				let _ = self.res.splice(..self.offset, iter::empty());
 				self.offset = 0;
 				if self.offset == self.res.len() {
 					continue 'chomp;
@@ -124,7 +124,7 @@ impl<I> WarcParser<I>
 where
 	I: AsyncRead,
 {
-	pub fn poll_next_borrowed(
+	pub(crate) fn poll_next_borrowed(
 		self: Pin<&mut Self>, cx: &mut Context,
 	) -> Poll<Result<Option<Webpage<'_>>, io::Error>> {
 		let mut self_ = self.project();
@@ -149,7 +149,7 @@ where
 			}
 
 			loop {
-				self_.res.splice(..*self_.offset, iter::empty());
+				let _ = self_.res.splice(..*self_.offset, iter::empty());
 				*self_.offset = 0;
 				if *self_.offset == self_.res.len() {
 					continue 'chomp;
diff --git a/amadeus-commoncrawl/src/lib.rs b/amadeus-commoncrawl/src/lib.rs
index c996b0db..6cca6ae0 100644
--- a/amadeus-commoncrawl/src/lib.rs
+++ b/amadeus-commoncrawl/src/lib.rs
@@ -1,5 +1,30 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-commoncrawl/0.2.5")]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::source`](https://docs.rs/amadeus/0.3/amadeus/source/index.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-commoncrawl/0.3.0")]
 #![feature(type_alias_impl_trait)]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::doc_markdown,
+	clippy::inline_always,
+	clippy::missing_errors_doc
+)]
+#![deny(unsafe_code)]
 
 mod commoncrawl;
 mod parser;
@@ -7,7 +32,7 @@ mod parser;
 use async_compression::futures::bufread::GzipDecoder; // TODO: use stream or https://github.com/alexcrichton/flate2-rs/pull/214
 use futures::{io::BufReader, AsyncBufReadExt, FutureExt, StreamExt, TryStreamExt};
 use reqwest_resume::ClientExt;
-use serde_closure::*;
+use serde_closure::FnMut;
 use std::{io, time};
 
 use amadeus_core::{
diff --git a/amadeus-commoncrawl/src/parser.rs b/amadeus-commoncrawl/src/parser.rs
index f589a33d..82ec7919 100644
--- a/amadeus-commoncrawl/src/parser.rs
+++ b/amadeus-commoncrawl/src/parser.rs
@@ -1,11 +1,11 @@
 //! Web ARChive format parser
 //!
 //! Takes data and separates records in headers and content.
-use nom::{space, Err, IResult, Needed, *};
+use nom::{complete, do_parse, many1, map_res, named, opt, space, tag, Err, IResult, Needed};
 use std::{fmt, str};
 
 #[derive(Clone, Copy, PartialEq, Eq)]
-pub enum RecordType {
+pub(crate) enum RecordType {
 	WARCInfo,
 	Response,
 	Resource,
@@ -16,7 +16,7 @@ pub enum RecordType {
 	Continuation,
 }
 impl RecordType {
-	pub fn parse(x: &str) -> RecordType {
+	pub(crate) fn parse(x: &str) -> RecordType {
 		match x {
 			"warcinfo" => RecordType::WARCInfo,
 			"response" => RecordType::Response,
@@ -33,14 +33,14 @@ impl RecordType {
 
 /// The WArc `Record` struct
 // #[derive(Clone)]
-pub struct Record<'a> {
-	// lazy design should not use pub
+pub(crate) struct Record<'a> {
+	// lazy design should not use pub(crate)
 	/// WArc headers
-	pub type_: RecordType,
-	pub target_uri: Option<&'a str>,
-	pub ip_address: Option<&'a str>,
+	pub(crate) type_: RecordType,
+	pub(crate) target_uri: Option<&'a str>,
+	pub(crate) ip_address: Option<&'a str>,
 	/// Content for call in a raw format
-	pub content: &'a [u8],
+	pub(crate) content: &'a [u8],
 }
 
 impl<'a> fmt::Debug for Record<'a> {
@@ -154,7 +154,7 @@ named!(warc_header<&[u8], ((&str, &str), Vec<(&str,&str)>) >,
 ///  }
 /// ```
 #[inline(always)]
-pub fn record(input: &[u8]) -> IResult<&[u8], Record> {
+pub(crate) fn record(input: &[u8]) -> IResult<&[u8], Record> {
 	// TODO if the stream parser does not get all the header it fails .
 	// like a default size of 10 doesnt for for a producer
 	warc_header(input).and_then(|(mut i, tuple_vec)| {
@@ -165,13 +165,13 @@ pub fn record(input: &[u8]) -> IResult<&[u8], Record> {
 		let mut type_ = None;
 		let mut target_uri = None;
 		let mut ip_address = None;
-		for &(k, v) in headers.iter() {
+		for &(k, v) in &headers {
 			match k {
 				"Content-Length" => {
 					let length_number = v.parse::<usize>().unwrap();
 					if length_number <= i.len() {
-						content = Some(&i[0..length_number as usize]);
-						i = &i[length_number as usize..];
+						content = Some(&i[0..length_number]);
+						i = &i[length_number..];
 						bytes_needed = 0;
 					} else {
 						bytes_needed = length_number - i.len();
@@ -232,4 +232,4 @@ named!(record_complete <&[u8], Record >,
 //      }
 //  }
 // ```
-named!(pub records<&[u8], Vec<Record> >, many1!(record_complete));
+named!(pub(crate) records<&[u8], Vec<Record> >, many1!(record_complete));
diff --git a/amadeus-core/Cargo.toml b/amadeus-core/Cargo.toml
index 8a12a7f7..88247864 100644
--- a/amadeus-core/Cargo.toml
+++ b/amadeus-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-core"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -32,6 +32,6 @@ replace_with = "0.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_closure = "0.2"
 streaming_algorithms = "0.2"
-sum = { version = "0.1", features = ["serde"] }
+sum = { version = "0.1", features = ["futures", "serde"] }
 walkdir = "2.2"
 widestring = "0.4"
diff --git a/amadeus-core/src/file.rs b/amadeus-core/src/file.rs
index e0773d1c..366a1504 100644
--- a/amadeus-core/src/file.rs
+++ b/amadeus-core/src/file.rs
@@ -305,7 +305,7 @@ where
 		let mut self_ = self.project();
 		if self_.pending.is_none() {
 			let start = *self_.offset;
-			let len = (self_.page.len() - start).min(buf.len() as u64) as usize;
+			let len = usize::try_from((self_.page.len() - start).min(buf.len() as u64)).unwrap();
 			let len = len.min(PAGE_SIZE);
 			let pending = self_.page.read(start, len);
 			*self_.pending = Some(pending);
diff --git a/amadeus-core/src/into_par_stream.rs b/amadeus-core/src/into_par_stream.rs
index 8d138811..61d6269c 100644
--- a/amadeus-core/src/into_par_stream.rs
+++ b/amadeus-core/src/into_par_stream.rs
@@ -1,4 +1,4 @@
-use crate::par_stream::{DistributedStream, ParallelStream, StreamTask, StreamTaskAsync};
+use crate::par_stream::{DistributedStream, ParallelStream, StreamTask};
 
 mod collections;
 mod iterator;
diff --git a/amadeus-core/src/into_par_stream/iterator.rs b/amadeus-core/src/into_par_stream/iterator.rs
index 4919cc48..8aa264bd 100644
--- a/amadeus-core/src/into_par_stream/iterator.rs
+++ b/amadeus-core/src/into_par_stream/iterator.rs
@@ -1,14 +1,14 @@
-use futures::{pin_mut, stream};
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	iter, ops::{Range, RangeFrom, RangeInclusive}, pin::Pin, task::{Context, Poll}
+	ops::{Range, RangeFrom, RangeInclusive}, pin::Pin, task::{Context, Poll}
 };
 
 use super::{
-	DistributedStream, IntoDistributedStream, IntoParallelStream, ParallelStream, StreamTask, StreamTaskAsync
+	DistributedStream, IntoDistributedStream, IntoParallelStream, ParallelStream, StreamTask
 };
-use crate::{pool::ProcessSend, sink::Sink};
+use crate::pool::ProcessSend;
 
 pub trait IteratorExt: Iterator + Sized {
 	fn par(self) -> IterParStream<Self> {
@@ -56,15 +56,11 @@ impl<T> StreamTask for IterStreamTask<T> {
 		self
 	}
 }
-impl<T> StreamTaskAsync for IterStreamTask<T> {
+impl<T> Stream for IterStreamTask<T> {
 	type Item = T;
 
-	fn poll_run(
-		mut self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let stream = stream::iter(iter::from_fn(|| self.0.take()));
-		pin_mut!(stream);
-		sink.poll_forward(cx, stream)
+	fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
+		Poll::Ready(self.project().0.take())
 	}
 }
 
diff --git a/amadeus-core/src/into_par_stream/slice.rs b/amadeus-core/src/into_par_stream/slice.rs
index 26ae9544..a47b95ab 100644
--- a/amadeus-core/src/into_par_stream/slice.rs
+++ b/amadeus-core/src/into_par_stream/slice.rs
@@ -1,12 +1,13 @@
+use futures::Stream;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::{
-	iter, pin::Pin, slice, task::{Context, Poll}
+	convert::Infallible, iter, pin::Pin, slice, task::{Context, Poll}
 };
 
 use super::{
-	DistributedStream, IntoDistributedStream, IntoParallelStream, IterDistStream, IterParStream, ParallelStream, StreamTask, StreamTaskAsync
+	DistributedStream, IntoDistributedStream, IntoParallelStream, IterDistStream, IterParStream, ParallelStream, StreamTask
 };
-use crate::{pool::ProcessSend, sink::Sink};
+use crate::pool::ProcessSend;
 
 impl_par_dist_rename! {
 	impl<T> IntoParallelStream for [T]
@@ -52,7 +53,7 @@ impl_par_dist_rename! {
 	}
 }
 
-pub struct Never(!);
+pub struct Never(Infallible);
 
 impl StreamTask for Never {
 	type Item = Self;
@@ -62,12 +63,10 @@ impl StreamTask for Never {
 		self
 	}
 }
-impl StreamTaskAsync for Never {
+impl Stream for Never {
 	type Item = Self;
 
-	fn poll_run(
-		self: Pin<&mut Self>, _cx: &mut Context, _sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
 		unreachable!()
 	}
 }
diff --git a/amadeus-core/src/lib.rs b/amadeus-core/src/lib.rs
index 58130ac8..9104029d 100644
--- a/amadeus-core/src/lib.rs
+++ b/amadeus-core/src/lib.rs
@@ -1,23 +1,55 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-core/0.2.5")]
-#![feature(never_type)]
-#![feature(specialization)]
-#![feature(read_initializer)]
-#![allow(incomplete_features)]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. All functionality is re-exposed in [`amadeus`](https://docs.rs/amadeus/0.3/amadeus/).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-core/0.3.0")]
 #![recursion_limit = "25600"]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::if_not_else,
+	clippy::similar_names,
+	clippy::type_repetition_in_bounds,
+	clippy::missing_errors_doc,
+	clippy::must_use_candidate,
+	clippy::unsafe_derive_deserialize,
+	clippy::inline_always,
+	clippy::option_option,
+	clippy::default_trait_access,
+	clippy::filter_map,
+	clippy::wildcard_imports,
+	clippy::needless_pass_by_value
+)]
+#![deny(unsafe_code)]
 
 macro_rules! impl_par_dist {
 	($($body:tt)*) => {
 		$($body)*
 		const _: () = {
-			use crate::impl_par_dist::*;
+			use $crate::impl_par_dist::*;
 			#[allow(unused_imports)]
-			use crate::impl_par_dist::{combiner_par_sink,folder_par_sink};
+			use $crate::impl_par_dist::{combiner_par_sink,folder_par_sink};
 			$($body)*
 		};
 	}
 }
 mod impl_par_dist {
-	pub use crate::{
+	#[allow(unused_imports)]
+	pub(crate) use crate::{
 		combiner_dist_sink as combiner_par_sink, folder_dist_sink as folder_par_sink, par_pipe::DistributedPipe as ParallelPipe, par_sink::{DistributedSink as ParallelSink, FromDistributedStream as FromParallelStream}, par_stream::DistributedStream as ParallelStream, pool::ProcessSend as Send
 	};
 }
@@ -66,8 +98,8 @@ pub mod misc_serde;
 pub mod par_pipe;
 pub mod par_sink;
 pub mod par_stream;
+pub mod pipe;
 pub mod pool;
-pub mod sink;
 mod source;
 pub mod util;
 
diff --git a/amadeus-core/src/par_pipe.rs b/amadeus-core/src/par_pipe.rs
index 4a62466e..3973e289 100644
--- a/amadeus-core/src/par_pipe.rs
+++ b/amadeus-core/src/par_pipe.rs
@@ -1,57 +1,18 @@
 use either::Either;
 use futures::Stream;
-use std::{
-	cmp::Ordering, future::Future, hash::Hash, iter, ops::{DerefMut, FnMut}, pin::Pin, task::{Context, Poll}
-};
+use std::{cmp::Ordering, hash::Hash, iter, ops::FnMut};
 
-use crate::{pool::ProcessSend, sink::Sink};
+use crate::{pipe::Pipe, pool::ProcessSend};
 
 use super::{par_sink::*, par_stream::*};
 
 #[must_use]
 pub trait PipeTask<Source> {
 	type Item;
-	type Async: PipeTaskAsync<Source, Item = Self::Item>;
+	type Async: Pipe<Source, Item = Self::Item>;
 
 	fn into_async(self) -> Self::Async;
 }
-#[must_use]
-pub trait PipeTaskAsync<Source> {
-	type Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()>;
-}
-
-impl<P, Source> PipeTaskAsync<Source> for Pin<P>
-where
-	P: DerefMut + Unpin,
-	P::Target: PipeTaskAsync<Source>,
-{
-	type Item = <P::Target as PipeTaskAsync<Source>>::Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		self.get_mut().as_mut().poll_run(cx, stream, sink)
-	}
-}
-impl<T: ?Sized, Source> PipeTaskAsync<Source> for &mut T
-where
-	T: PipeTaskAsync<Source> + Unpin,
-{
-	type Item = T::Item;
-
-	fn poll_run(
-		mut self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		Pin::new(&mut **self).poll_run(cx, stream, sink)
-	}
-}
 
 impl_par_dist_rename! {
 	#[must_use]
@@ -94,10 +55,9 @@ impl_par_dist_rename! {
 			assert_parallel_pipe(FlatMap::new(self, f))
 		}
 
-		fn filter<F, Fut>(self, f: F) -> Filter<Self, F>
+		fn filter<F>(self, f: F) -> Filter<Self, F>
 		where
-			F: FnMut(&Self::Item) -> Fut + Clone + Send + 'static,
-			Fut: Future<Output = bool>,
+			F: FnMut(&Self::Item) -> bool + Clone + Send + 'static,
 			Self: Sized,
 		{
 			assert_parallel_pipe(Filter::new(self, f))
@@ -121,12 +81,21 @@ impl_par_dist_rename! {
 		// 	assert_parallel_pipe(Chain::new(self, chain.into_par_stream()))
 		// }
 
-		fn pipe<S>(self, sink: S) -> Pipe<Self, S>
+		fn pipe<S>(self, sink: S) -> super::par_sink::Pipe<Self, S>
 		where
 			S: ParallelSink<Self::Item>,
 			Self: Sized,
 		{
-			assert_parallel_sink(Pipe::new(self, sink))
+			assert_parallel_sink(super::par_sink::Pipe::new(self, sink))
+		}
+
+		fn fork<A, B, RefAItem>(self, sink: A, sink_ref: B) -> Fork<Self, A, B, &'static Self::Item>
+		where
+			A: ParallelSink<Self::Item>,
+			B: for<'a> ParallelSink<&'a Self::Item>,
+			Self: Sized,
+		{
+			assert_parallel_sink(Fork::new(self, sink, sink_ref))
 		}
 
 		fn for_each<F>(self, f: F) -> ForEach<Self, F>
@@ -147,15 +116,17 @@ impl_par_dist_rename! {
 			assert_parallel_sink(Fold::new(self, identity, op))
 		}
 
-		fn group_by<A, B, ID, F, C>(self, identity: ID, op: F) -> GroupBy<Self, ID, F, C>
+		fn group_by<S, A, B>(self, sink: S) -> GroupBy<Self, S>
 		where
 			A: Eq + Hash + Send + 'static,
-			ID: FnMut() -> C + Clone + Send + 'static,
-			F: FnMut(C, Either<B, C>) -> C + Clone + Send + 'static,
-			C: Send + 'static,
+			S: ParallelSink<B>,
+			<S::Pipe as ParallelPipe<B>>::Task: Clone + Send + 'static,
+			S::ReduceA: 'static,
+			S::ReduceC: Clone,
+			S::Output: Send + 'static,
 			Self: ParallelPipe<Source, Item = (A, B)> + Sized,
 		{
-			assert_parallel_sink(GroupBy::new(self, identity, op))
+			assert_parallel_sink(GroupBy::new(self, sink))
 		}
 
 		fn histogram(self) -> Histogram<Self>
diff --git a/amadeus-core/src/par_sink.rs b/amadeus-core/src/par_sink.rs
index 56b2e2ff..21d97a15 100644
--- a/amadeus-core/src/par_sink.rs
+++ b/amadeus-core/src/par_sink.rs
@@ -7,6 +7,7 @@ mod count;
 mod fold;
 mod folder;
 mod for_each;
+mod fork;
 mod group_by;
 mod histogram;
 mod max;
@@ -15,122 +16,103 @@ mod sample;
 mod sum;
 mod tuple;
 
-use futures::Stream;
-use std::{
-	ops::DerefMut, pin::Pin, task::{Context, Poll}
-};
+use std::{future::Future, ops::DerefMut, pin::Pin};
 
-use crate::pool::ProcessSend;
+use crate::{pipe::Sink, pool::ProcessSend};
 
 use super::par_pipe::*;
 
 pub use self::{
-	all::*, any::*, collect::*, combine::*, combiner::*, count::*, fold::*, folder::*, for_each::*, group_by::*, histogram::*, max::*, pipe::*, sample::*, sum::*, tuple::*
+	all::*, any::*, collect::*, combine::*, combiner::*, count::*, fold::*, folder::*, for_each::*, fork::*, group_by::*, histogram::*, max::*, pipe::*, sample::*, sum::*, tuple::*
 };
 
 #[must_use]
-pub trait Reducer {
-	type Item;
+pub trait Reducer<Source> {
 	type Output;
-	type Async: ReducerAsync<Item = Self::Item, Output = Self::Output>;
+	type Async: ReducerAsync<Source, Output = Self::Output>;
 
 	fn into_async(self) -> Self::Async;
 }
-#[must_use]
-pub trait ReducerAsync {
-	type Item;
-	type Output;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()>;
-	fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>;
-}
-pub trait ReducerSend: Reducer<Output = <Self as ReducerSend>::Output> {
+pub trait ReducerSend<Source>:
+	Reducer<Source, Output = <Self as ReducerSend<Source>>::Output>
+{
 	type Output: Send + 'static;
 }
-pub trait ReducerProcessSend: ReducerSend<Output = <Self as ReducerProcessSend>::Output> {
+pub trait ReducerProcessSend<Source>:
+	ReducerSend<Source, Output = <Self as ReducerProcessSend<Source>>::Output>
+{
 	type Output: ProcessSend + 'static;
 }
+#[must_use]
+pub trait ReducerAsync<Source>: Sink<Source> {
+	type Output;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>;
+}
 
-impl<P> ReducerAsync for Pin<P>
+impl<P, Source> ReducerAsync<Source> for Pin<P>
 where
 	P: DerefMut + Unpin,
-	P::Target: ReducerAsync,
+	P::Target: ReducerAsync<Source>,
 {
-	type Item = <P::Target as ReducerAsync>::Item;
-	type Output = <P::Target as ReducerAsync>::Output;
+	type Output = <P::Target as ReducerAsync<Source>>::Output;
 
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		self.get_mut().as_mut().poll_forward(cx, stream)
-	}
-	fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		self.get_mut().as_mut().poll_output(cx)
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		self.get_mut().as_mut().output()
 	}
 }
-impl<T: ?Sized> ReducerAsync for &mut T
+impl<T: ?Sized, Source> ReducerAsync<Source> for &mut T
 where
-	T: ReducerAsync + Unpin,
+	T: ReducerAsync<Source> + Unpin,
 {
-	type Item = T::Item;
 	type Output = T::Output;
 
-	fn poll_forward(
-		mut self: Pin<&mut Self>, cx: &mut Context,
-		stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		Pin::new(&mut **self).poll_forward(cx, stream)
+	fn output<'a>(mut self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { Pin::new(&mut **self).output().await })
 	}
-	fn poll_output(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		Pin::new(&mut **self).poll_output(cx)
-	}
-}
-
-pub trait Factory {
-	type Item;
-
-	fn make(&self) -> Self::Item;
 }
 
 #[must_use]
-pub trait DistributedSink<Source> {
+pub trait ParallelSink<Source> {
 	type Output;
-	type Pipe: DistributedPipe<Source>;
-	type ReduceAFactory: Factory<Item = Self::ReduceA> + Clone + ProcessSend;
-	type ReduceBFactory: Factory<Item = Self::ReduceB>;
-	type ReduceA: ReducerSend<Item = <Self::Pipe as DistributedPipe<Source>>::Item> + Send;
-	type ReduceB: ReducerProcessSend<Item = <Self::ReduceA as Reducer>::Output> + ProcessSend;
-	type ReduceC: Reducer<Item = <Self::ReduceB as Reducer>::Output, Output = Self::Output>;
-
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	);
+	type Pipe: ParallelPipe<Source>;
+	type ReduceA: ReducerSend<<Self::Pipe as ParallelPipe<Source>>::Item> + Clone + Send;
+	type ReduceC: Reducer<
+		<Self::ReduceA as ReducerSend<<Self::Pipe as ParallelPipe<Source>>::Item>>::Output,
+		Output = Self::Output,
+	>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC);
 }
 
 #[inline(always)]
-pub(crate) fn assert_distributed_sink<R: DistributedSink<Source>, Source>(r: R) -> R {
+pub(crate) fn assert_parallel_sink<R: ParallelSink<Source>, Source>(r: R) -> R {
 	r
 }
 
 #[must_use]
-pub trait ParallelSink<Source> {
+pub trait DistributedSink<Source> {
 	type Output;
-	type Pipe: ParallelPipe<Source>;
-	type ReduceAFactory: Factory<Item = Self::ReduceA>;
-	type ReduceA: ReducerSend<Item = <Self::Pipe as ParallelPipe<Source>>::Item> + Send;
-	type ReduceC: Reducer<Item = <Self::ReduceA as Reducer>::Output, Output = Self::Output>;
-
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC);
+	type Pipe: DistributedPipe<Source>;
+	type ReduceA: ReducerSend<<Self::Pipe as DistributedPipe<Source>>::Item>
+		+ Clone
+		+ ProcessSend
+		+ Send;
+	type ReduceB: ReducerProcessSend<
+			<Self::ReduceA as ReducerSend<<Self::Pipe as DistributedPipe<Source>>::Item>>::Output,
+		> + Clone
+		+ ProcessSend;
+	type ReduceC: Reducer<
+		<Self::ReduceB as ReducerProcessSend<
+			<Self::ReduceA as ReducerSend<<Self::Pipe as DistributedPipe<Source>>::Item>>::Output,
+		>>::Output,
+		Output = Self::Output,
+	>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC);
 }
 
 #[inline(always)]
-pub(crate) fn assert_parallel_sink<R: ParallelSink<Source>, Source>(r: R) -> R {
+pub(crate) fn assert_distributed_sink<R: DistributedSink<Source>, Source>(r: R) -> R {
 	r
 }
diff --git a/amadeus-core/src/par_sink/all.rs b/amadeus-core/src/par_sink/all.rs
index a80a6aa6..cd46f3d1 100644
--- a/amadeus-core/src/par_sink/all.rs
+++ b/amadeus-core/src/par_sink/all.rs
@@ -1,15 +1,16 @@
 use derive_new::new;
+use educe::Educe;
 use futures::{ready, Stream};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	marker::PhantomData, pin::Pin, task::{Context, Poll}
+	future::Future, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
 use super::{
-	DistributedPipe, DistributedSink, Factory, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
 };
-use crate::pool::ProcessSend;
+use crate::{pipe::Sink, pool::ProcessSend};
 
 #[derive(new)]
 #[must_use]
@@ -18,75 +19,69 @@ pub struct All<I, F> {
 	f: F,
 }
 
-impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for All<I, F>
+impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for All<I, F>
 where
-	F: FnMut(I::Item) -> bool + Clone + ProcessSend + 'static,
+	F: FnMut(I::Item) -> bool + Clone + Send + 'static,
 {
 	type Output = bool;
 	type Pipe = I;
-	type ReduceAFactory = AllReducerFactory<I::Item, F>;
-	type ReduceBFactory = BoolAndReducerFactory;
 	type ReduceA = AllReducer<I::Item, F>;
-	type ReduceB = BoolAndReducer;
 	type ReduceC = BoolAndReducer;
 
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	) {
-		(
-			self.i,
-			AllReducerFactory(self.f, PhantomData),
-			BoolAndReducerFactory,
-			BoolAndReducer(true),
-		)
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
+		(self.i, AllReducer(self.f, PhantomData), BoolAndReducer)
 	}
 }
-impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for All<I, F>
+impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for All<I, F>
 where
-	F: FnMut(I::Item) -> bool + Clone + Send + 'static,
+	F: FnMut(I::Item) -> bool + Clone + ProcessSend + 'static,
 {
 	type Output = bool;
 	type Pipe = I;
-	type ReduceAFactory = AllReducerFactory<I::Item, F>;
 	type ReduceA = AllReducer<I::Item, F>;
+	type ReduceB = BoolAndReducer;
 	type ReduceC = BoolAndReducer;
 
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		(
 			self.i,
-			AllReducerFactory(self.f, PhantomData),
-			BoolAndReducer(true),
+			AllReducer(self.f, PhantomData),
+			BoolAndReducer,
+			BoolAndReducer,
 		)
 	}
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone(bound = "F: Clone"))]
 #[serde(
 	bound(serialize = "F: Serialize"),
 	bound(deserialize = "F: Deserialize<'de>")
 )]
-pub struct AllReducerFactory<A, F>(F, PhantomData<fn() -> A>);
-impl<A, F> Factory for AllReducerFactory<A, F>
+pub struct AllReducer<A, F>(F, PhantomData<fn() -> A>);
+
+impl<A, F> Reducer<A> for AllReducer<A, F>
 where
-	F: FnMut(A) -> bool + Clone,
+	F: FnMut(A) -> bool,
 {
-	type Item = AllReducer<A, F>;
-	fn make(&self) -> Self::Item {
-		AllReducer(self.0.clone(), true, PhantomData)
+	type Output = bool;
+	type Async = AllReducerAsync<A, F>;
+
+	fn into_async(self) -> Self::Async {
+		AllReducerAsync(self.0, true, PhantomData)
 	}
 }
-impl<A, F> Clone for AllReducerFactory<A, F>
+impl<A, F> ReducerProcessSend<A> for AllReducer<A, F>
 where
-	F: Clone,
+	F: FnMut(A) -> bool,
 {
-	fn clone(&self) -> Self {
-		Self(self.0.clone(), PhantomData)
-	}
+	type Output = bool;
+}
+impl<A, F> ReducerSend<A> for AllReducer<A, F>
+where
+	F: FnMut(A) -> bool,
+{
+	type Output = bool;
 }
 
 #[pin_project]
@@ -95,30 +90,15 @@ where
 	bound(serialize = "F: Serialize"),
 	bound(deserialize = "F: Deserialize<'de>")
 )]
-pub struct AllReducer<A, F>(F, bool, PhantomData<fn() -> A>);
+pub struct AllReducerAsync<A, F>(F, bool, PhantomData<fn() -> A>);
 
-impl<A, F> Reducer for AllReducer<A, F>
-where
-	F: FnMut(A) -> bool,
-{
-	type Item = A;
-	type Output = bool;
-	type Async = Self;
-	fn into_async(self) -> Self::Async {
-		self
-	}
-}
-impl<A, F> ReducerAsync for AllReducer<A, F>
+impl<A, F> Sink<A> for AllReducerAsync<A, F>
 where
 	F: FnMut(A) -> bool,
 {
-	type Item = A;
-	type Output = bool;
-
 	#[inline(always)]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		while *self_.1 {
@@ -130,52 +110,42 @@ where
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(self.1)
-	}
-}
-impl<A, F> ReducerProcessSend for AllReducer<A, F>
-where
-	F: FnMut(A) -> bool,
-{
-	type Output = bool;
 }
-impl<A, F> ReducerSend for AllReducer<A, F>
+impl<A, F> ReducerAsync<A> for AllReducerAsync<A, F>
 where
 	F: FnMut(A) -> bool,
 {
 	type Output = bool;
-}
 
-#[derive(Serialize, Deserialize)]
-pub struct BoolAndReducerFactory;
-impl Factory for BoolAndReducerFactory {
-	type Item = BoolAndReducer;
-	fn make(&self) -> Self::Item {
-		BoolAndReducer(true)
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.1 })
 	}
 }
 
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-pub struct BoolAndReducer(bool);
+#[derive(Clone, Serialize, Deserialize)]
+pub struct BoolAndReducer;
 
-impl Reducer for BoolAndReducer {
-	type Item = bool;
+impl Reducer<bool> for BoolAndReducer {
 	type Output = bool;
-	type Async = Self;
+	type Async = BoolAndReducerAsync;
+
 	fn into_async(self) -> Self::Async {
-		self
+		BoolAndReducerAsync(true)
 	}
 }
-impl ReducerAsync for BoolAndReducer {
-	type Item = bool;
+impl ReducerProcessSend<bool> for BoolAndReducer {
+	type Output = bool;
+}
+impl ReducerSend<bool> for BoolAndReducer {
 	type Output = bool;
+}
 
+#[pin_project]
+pub struct BoolAndReducerAsync(bool);
+impl Sink<bool> for BoolAndReducerAsync {
 	#[inline(always)]
-	fn poll_forward(
-		mut self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		mut self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = bool>>,
 	) -> Poll<()> {
 		while self.0 {
 			if let Some(item) = ready!(stream.as_mut().poll_next(cx)) {
@@ -186,13 +156,11 @@ impl ReducerAsync for BoolAndReducer {
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(self.0)
-	}
 }
-impl ReducerProcessSend for BoolAndReducer {
-	type Output = bool;
-}
-impl ReducerSend for BoolAndReducer {
+impl ReducerAsync<bool> for BoolAndReducerAsync {
 	type Output = bool;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.0 })
+	}
 }
diff --git a/amadeus-core/src/par_sink/any.rs b/amadeus-core/src/par_sink/any.rs
index 51810684..a6b8ab48 100644
--- a/amadeus-core/src/par_sink/any.rs
+++ b/amadeus-core/src/par_sink/any.rs
@@ -1,15 +1,16 @@
 use derive_new::new;
+use educe::Educe;
 use futures::{ready, Stream};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	marker::PhantomData, pin::Pin, task::{Context, Poll}
+	future::Future, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
 use super::{
-	DistributedPipe, DistributedSink, Factory, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
 };
-use crate::pool::ProcessSend;
+use crate::{pipe::Sink, pool::ProcessSend};
 
 #[derive(new)]
 #[must_use]
@@ -18,75 +19,69 @@ pub struct Any<I, F> {
 	f: F,
 }
 
-impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for Any<I, F>
+impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for Any<I, F>
 where
-	F: FnMut(I::Item) -> bool + Clone + ProcessSend + 'static,
+	F: FnMut(I::Item) -> bool + Clone + Send + 'static,
 {
 	type Output = bool;
 	type Pipe = I;
-	type ReduceAFactory = AnyReducerFactory<I::Item, F>;
-	type ReduceBFactory = BoolOrReducerFactory;
 	type ReduceA = AnyReducer<I::Item, F>;
-	type ReduceB = BoolOrReducer;
 	type ReduceC = BoolOrReducer;
 
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	) {
-		(
-			self.i,
-			AnyReducerFactory(self.f, PhantomData),
-			BoolOrReducerFactory,
-			BoolOrReducer(true),
-		)
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
+		(self.i, AnyReducer(self.f, PhantomData), BoolOrReducer)
 	}
 }
-impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for Any<I, F>
+impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for Any<I, F>
 where
-	F: FnMut(I::Item) -> bool + Clone + Send + 'static,
+	F: FnMut(I::Item) -> bool + Clone + ProcessSend + 'static,
 {
 	type Output = bool;
 	type Pipe = I;
-	type ReduceAFactory = AnyReducerFactory<I::Item, F>;
 	type ReduceA = AnyReducer<I::Item, F>;
+	type ReduceB = BoolOrReducer;
 	type ReduceC = BoolOrReducer;
 
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		(
 			self.i,
-			AnyReducerFactory(self.f, PhantomData),
-			BoolOrReducer(true),
+			AnyReducer(self.f, PhantomData),
+			BoolOrReducer,
+			BoolOrReducer,
 		)
 	}
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone(bound = "F: Clone"))]
 #[serde(
 	bound(serialize = "F: Serialize"),
 	bound(deserialize = "F: Deserialize<'de>")
 )]
-pub struct AnyReducerFactory<A, F>(F, PhantomData<fn() -> A>);
-impl<A, F> Factory for AnyReducerFactory<A, F>
+pub struct AnyReducer<A, F>(F, PhantomData<fn() -> A>);
+
+impl<A, F> Reducer<A> for AnyReducer<A, F>
 where
-	F: FnMut(A) -> bool + Clone,
+	F: FnMut(A) -> bool,
 {
-	type Item = AnyReducer<A, F>;
-	fn make(&self) -> Self::Item {
-		AnyReducer(self.0.clone(), true, PhantomData)
+	type Output = bool;
+	type Async = AnyReducerAsync<A, F>;
+
+	fn into_async(self) -> Self::Async {
+		AnyReducerAsync(self.0, true, PhantomData)
 	}
 }
-impl<A, F> Clone for AnyReducerFactory<A, F>
+impl<A, F> ReducerProcessSend<A> for AnyReducer<A, F>
 where
-	F: Clone,
+	F: FnMut(A) -> bool,
 {
-	fn clone(&self) -> Self {
-		Self(self.0.clone(), PhantomData)
-	}
+	type Output = bool;
+}
+impl<A, F> ReducerSend<A> for AnyReducer<A, F>
+where
+	F: FnMut(A) -> bool,
+{
+	type Output = bool;
 }
 
 #[pin_project]
@@ -95,30 +90,15 @@ where
 	bound(serialize = "F: Serialize"),
 	bound(deserialize = "F: Deserialize<'de>")
 )]
-pub struct AnyReducer<A, F>(F, bool, PhantomData<fn() -> A>);
+pub struct AnyReducerAsync<A, F>(F, bool, PhantomData<fn() -> A>);
 
-impl<A, F> Reducer for AnyReducer<A, F>
-where
-	F: FnMut(A) -> bool,
-{
-	type Item = A;
-	type Output = bool;
-	type Async = Self;
-	fn into_async(self) -> Self::Async {
-		self
-	}
-}
-impl<A, F> ReducerAsync for AnyReducer<A, F>
+impl<A, F> Sink<A> for AnyReducerAsync<A, F>
 where
 	F: FnMut(A) -> bool,
 {
-	type Item = A;
-	type Output = bool;
-
 	#[inline(always)]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		while *self_.1 {
@@ -130,52 +110,44 @@ where
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(!self.1)
-	}
 }
-impl<A, F> ReducerProcessSend for AnyReducer<A, F>
+impl<A, F> ReducerAsync<A> for AnyReducerAsync<A, F>
 where
 	F: FnMut(A) -> bool,
 {
 	type Output = bool;
-}
-impl<A, F> ReducerSend for AnyReducer<A, F>
-where
-	F: FnMut(A) -> bool,
-{
-	type Output = bool;
-}
 
-#[derive(Serialize, Deserialize)]
-pub struct BoolOrReducerFactory;
-impl Factory for BoolOrReducerFactory {
-	type Item = BoolOrReducer;
-	fn make(&self) -> Self::Item {
-		BoolOrReducer(true)
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { !self.1 })
 	}
 }
 
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-pub struct BoolOrReducer(bool);
+#[derive(Clone, Serialize, Deserialize)]
+pub struct BoolOrReducer;
 
-impl Reducer for BoolOrReducer {
-	type Item = bool;
+impl Reducer<bool> for BoolOrReducer {
 	type Output = bool;
-	type Async = Self;
+	type Async = BoolOrReducerAsync;
+
 	fn into_async(self) -> Self::Async {
-		self
+		BoolOrReducerAsync(true)
 	}
 }
-impl ReducerAsync for BoolOrReducer {
-	type Item = bool;
+impl ReducerProcessSend<bool> for BoolOrReducer {
 	type Output = bool;
+}
+impl ReducerSend<bool> for BoolOrReducer {
+	type Output = bool;
+}
+
+#[pin_project]
+#[derive(Serialize, Deserialize)]
+pub struct BoolOrReducerAsync(bool);
 
+impl Sink<bool> for BoolOrReducerAsync {
 	#[inline(always)]
-	fn poll_forward(
-		mut self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		mut self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = bool>>,
 	) -> Poll<()> {
 		while self.0 {
 			if let Some(item) = ready!(stream.as_mut().poll_next(cx)) {
@@ -186,13 +158,11 @@ impl ReducerAsync for BoolOrReducer {
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(!self.0)
-	}
 }
-impl ReducerProcessSend for BoolOrReducer {
-	type Output = bool;
-}
-impl ReducerSend for BoolOrReducer {
+impl ReducerAsync<bool> for BoolOrReducerAsync {
 	type Output = bool;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { !self.0 })
+	}
 }
diff --git a/amadeus-core/src/par_sink/collect.rs b/amadeus-core/src/par_sink/collect.rs
index e252b38b..815cc6b9 100644
--- a/amadeus-core/src/par_sink/collect.rs
+++ b/amadeus-core/src/par_sink/collect.rs
@@ -1,15 +1,16 @@
 use derive_new::new;
+use educe::Educe;
 use futures::{pin_mut, ready, Stream, StreamExt};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque}, hash::{BuildHasher, Hash}, iter, marker::PhantomData, pin::Pin, task::{Context, Poll}
+	collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque}, future::Future, hash::{BuildHasher, Hash}, iter, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
 use super::{
-	DistributedPipe, DistributedSink, Factory, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
 };
-use crate::pool::ProcessSend;
+use crate::{pipe::Sink, pool::ProcessSend};
 
 #[derive(new)]
 #[must_use]
@@ -23,11 +24,10 @@ impl<I: ParallelPipe<Source>, Source, T: FromParallelStream<I::Item>> ParallelSi
 {
 	type Output = T;
 	type Pipe = I;
-	type ReduceAFactory = T::ReduceAFactory;
 	type ReduceA = T::ReduceA;
 	type ReduceC = T::ReduceC;
 
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
 		let (a, b) = T::reducers();
 		(self.i, a, b)
 	}
@@ -37,106 +37,69 @@ impl<I: DistributedPipe<Source>, Source, T: FromDistributedStream<I::Item>> Dist
 {
 	type Output = T;
 	type Pipe = I;
-	type ReduceAFactory = T::ReduceAFactory;
-	type ReduceBFactory = T::ReduceBFactory;
 	type ReduceA = T::ReduceA;
 	type ReduceB = T::ReduceB;
 	type ReduceC = T::ReduceC;
 
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		let (a, b, c) = T::reducers();
 		(self.i, a, b, c)
 	}
 }
 
-pub trait FromDistributedStream<T>: Sized {
-	type ReduceAFactory: Factory<Item = Self::ReduceA> + Clone + ProcessSend;
-	type ReduceBFactory: Factory<Item = Self::ReduceB>;
-	type ReduceA: ReducerSend<Item = T> + Send;
-	type ReduceB: ReducerProcessSend<Item = <Self::ReduceA as Reducer>::Output> + ProcessSend;
-	type ReduceC: Reducer<Item = <Self::ReduceB as Reducer>::Output, Output = Self>;
+pub trait FromParallelStream<T>: Sized {
+	type ReduceA: ReducerSend<T> + Clone + Send;
+	type ReduceC: Reducer<<Self::ReduceA as ReducerSend<T>>::Output, Output = Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC);
-	// 	fn from_dist_stream<I>(dist_stream: I, pool: &Pool) -> Self where T: Serialize + DeserializeOwned + Send + 'static, I: IntoDistributedStream<Item = T>, <<I as IntoDistributedStream>::Iter as DistributedStream>::Task: Serialize + DeserializeOwned + Send + 'static;
+	fn reducers() -> (Self::ReduceA, Self::ReduceC);
 }
 
-pub trait FromParallelStream<T>: Sized {
-	type ReduceAFactory: Factory<Item = Self::ReduceA>;
-	type ReduceA: ReducerSend<Item = T> + Send;
-	type ReduceC: Reducer<Item = <Self::ReduceA as Reducer>::Output, Output = Self>;
-
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC);
+pub trait FromDistributedStream<T>: Sized {
+	type ReduceA: ReducerSend<T> + Clone + ProcessSend;
+	type ReduceB: ReducerProcessSend<<Self::ReduceA as ReducerSend<T>>::Output>
+		+ Clone
+		+ ProcessSend;
+	type ReduceC: Reducer<
+		<Self::ReduceB as ReducerProcessSend<<Self::ReduceA as ReducerSend<T>>::Output>>::Output,
+		Output = Self,
+	>;
+
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC);
+	// 	fn from_dist_stream<I>(dist_stream: I, pool: &Pool) -> Self where T: Serialize + DeserializeOwned + Send + 'static, I: IntoDistributedStream<Item = T>, <<I as IntoDistributedStream>::Iter as DistributedStream>::Task: Serialize + DeserializeOwned + Send + 'static;
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Educe, Serialize, Deserialize, new)]
+#[educe(Clone, Default)]
 #[serde(bound = "")]
-pub struct DefaultReducerFactory<T>(PhantomData<fn() -> T>);
-impl<T> DefaultReducerFactory<T> {
-	pub fn new() -> Self {
-		Self(PhantomData)
-	}
-}
-impl<T> Default for DefaultReducerFactory<T> {
-	fn default() -> Self {
-		Self(PhantomData)
-	}
-}
-impl<T: Default + Reducer> Factory for DefaultReducerFactory<T> {
-	type Item = T;
-	fn make(&self) -> Self::Item {
-		T::default()
-	}
-}
-impl<T> Clone for DefaultReducerFactory<T> {
-	fn clone(&self) -> Self {
-		Self(PhantomData)
-	}
-}
+pub struct PushReducer<A, T = A>(PhantomData<fn() -> (T, A)>);
 
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-#[serde(
-	bound(serialize = "T: Serialize"),
-	bound(deserialize = "T: Deserialize<'de>")
-)]
-pub struct PushReducer<A, T = A>(Option<T>, PhantomData<fn() -> A>);
-impl<A, T> PushReducer<A, T> {
-	pub(crate) fn new(t: T) -> Self {
-		Self(Some(t), PhantomData)
+impl<A, T: Default + Extend<A>> Reducer<A> for PushReducer<A, T> {
+	type Output = T;
+	type Async = PushReducerAsync<A, T>;
+
+	fn into_async(self) -> Self::Async {
+		PushReducerAsync(Some(Default::default()), PhantomData)
 	}
 }
-impl<A, T> Default for PushReducer<A, T>
+impl<A, T: Default + Extend<A>> ReducerProcessSend<A> for PushReducer<A, T>
 where
-	T: Default,
+	T: ProcessSend + 'static,
 {
-	fn default() -> Self {
-		Self(Some(T::default()), PhantomData)
-	}
-}
-impl<A, T: Extend<A>> Reducer for PushReducer<A, T> {
-	type Item = A;
 	type Output = T;
-	type Async = Self;
-
-	fn into_async(self) -> Self::Async {
-		self
-	}
 }
-impl<A, T: Extend<A>> ReducerAsync for PushReducer<A, T> {
-	type Item = A;
+impl<A, T: Default + Extend<A>> ReducerSend<A> for PushReducer<A, T>
+where
+	T: Send + 'static,
+{
 	type Output = T;
+}
 
+#[pin_project]
+pub struct PushReducerAsync<A, T = A>(Option<T>, PhantomData<fn() -> A>);
+impl<A, T: Extend<A>> Sink<A> for PushReducerAsync<A, T> {
 	#[inline]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		while let Some(item) = ready!(stream.as_mut().poll_next(cx)) {
@@ -144,67 +107,47 @@ impl<A, T: Extend<A>> ReducerAsync for PushReducer<A, T> {
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(self.0.take().unwrap())
-	}
 }
-impl<A, T: Extend<A>> ReducerProcessSend for PushReducer<A, T>
-where
-	T: ProcessSend + 'static,
-{
+impl<A, T: Extend<A>> ReducerAsync<A> for PushReducerAsync<A, T> {
 	type Output = T;
+
+	fn output<'a>(mut self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.0.take().unwrap() })
+	}
 }
-impl<A, T: Extend<A>> ReducerSend for PushReducer<A, T>
-where
-	T: Send + 'static,
-{
+
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone, Default)]
+#[serde(bound = "")]
+pub struct ExtendReducer<A, T = A>(PhantomData<fn() -> (T, A)>);
+impl<A: IntoIterator<Item = B>, T: Default + Extend<B>, B> Reducer<A> for ExtendReducer<A, T> {
 	type Output = T;
-}
+	type Async = ExtendReducerAsync<A, T>;
 
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-#[serde(
-	bound(serialize = "T: Serialize"),
-	bound(deserialize = "T: Deserialize<'de>")
-)]
-pub struct ExtendReducer<A, T = A>(Option<T>, PhantomData<fn() -> A>);
-impl<A, T> Default for ExtendReducer<A, T>
-where
-	T: Default,
-{
-	fn default() -> Self {
-		Self(Some(T::default()), PhantomData)
+	fn into_async(self) -> Self::Async {
+		ExtendReducerAsync(Some(T::default()), PhantomData)
 	}
 }
-impl<A: IntoIterator<Item = B>, T: Extend<B>, B> ReducerProcessSend for ExtendReducer<A, T>
+impl<A: IntoIterator<Item = B>, T: Default + Extend<B>, B> ReducerProcessSend<A>
+	for ExtendReducer<A, T>
 where
 	T: ProcessSend + 'static,
 {
 	type Output = T;
 }
-impl<A: IntoIterator<Item = B>, T: Extend<B>, B> ReducerSend for ExtendReducer<A, T>
+impl<A: IntoIterator<Item = B>, T: Default + Extend<B>, B> ReducerSend<A> for ExtendReducer<A, T>
 where
 	T: Send + 'static,
 {
 	type Output = T;
 }
-impl<A: IntoIterator<Item = B>, T: Extend<B>, B> Reducer for ExtendReducer<A, T> {
-	type Item = A;
-	type Output = T;
-	type Async = Self;
-
-	fn into_async(self) -> Self::Async {
-		self
-	}
-}
-impl<A: IntoIterator<Item = B>, T: Extend<B>, B> ReducerAsync for ExtendReducer<A, T> {
-	type Item = A;
-	type Output = T;
 
+#[pin_project]
+pub struct ExtendReducerAsync<A, T = A>(Option<T>, PhantomData<fn() -> A>);
+impl<A: IntoIterator<Item = B>, T: Extend<B>, B> Sink<A> for ExtendReducerAsync<A, T> {
 	#[inline]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		while let Some(item) = ready!(stream.as_mut().poll_next(cx)) {
@@ -212,90 +155,93 @@ impl<A: IntoIterator<Item = B>, T: Extend<B>, B> ReducerAsync for ExtendReducer<
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(self.0.take().unwrap())
-	}
 }
+impl<A: IntoIterator<Item = B>, T: Extend<B>, B> ReducerAsync<A> for ExtendReducerAsync<A, T> {
+	type Output = T;
 
-#[pin_project]
-pub struct IntoReducer<R, T>(#[pin] R, PhantomData<fn() -> T>);
-impl<R, T> Default for IntoReducer<R, T>
-where
-	R: Default,
-{
-	fn default() -> Self {
-		Self(R::default(), PhantomData)
+	fn output<'a>(mut self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.0.take().unwrap() })
 	}
 }
-impl<R: Reducer, T> Reducer for IntoReducer<R, T>
+
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone(bound = "R: Clone"), Default(bound = "R: Default"))]
+#[serde(
+	bound(serialize = "R: Serialize"),
+	bound(deserialize = "R: Deserialize<'de>")
+)]
+pub struct IntoReducer<R, T>(R, PhantomData<fn() -> T>);
+
+impl<R: Reducer<Item>, T, Item> Reducer<Item> for IntoReducer<R, T>
 where
 	R::Output: Into<T>,
 {
-	type Item = R::Item;
 	type Output = T;
-	type Async = IntoReducer<R::Async, T>;
+	type Async = IntoReducerAsync<R::Async, T>;
 
 	fn into_async(self) -> Self::Async {
-		IntoReducer(self.0.into_async(), PhantomData)
+		IntoReducerAsync(self.0.into_async(), PhantomData)
 	}
 }
-impl<R: ReducerAsync, T> ReducerAsync for IntoReducer<R, T>
+
+#[pin_project]
+pub struct IntoReducerAsync<R, T>(#[pin] R, PhantomData<fn() -> T>);
+
+impl<R: ReducerAsync<Item>, T, Item> Sink<Item> for IntoReducerAsync<R, T>
 where
 	R::Output: Into<T>,
 {
-	type Item = R::Item;
-	type Output = T;
-
 	#[inline]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Item>>,
 	) -> Poll<()> {
 		let stream = stream.map(Into::into);
 		pin_mut!(stream);
-		self.project().0.poll_forward(cx, stream)
-	}
-	fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		self.project().0.poll_output(cx).map(Into::into)
+		self.project().0.poll_pipe(cx, stream)
 	}
 }
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct OptionReducerFactory<RF: Factory>(RF);
-impl<RF: Factory> Factory for OptionReducerFactory<RF> {
-	type Item = OptionReducer<RF::Item>;
-
-	fn make(&self) -> Self::Item {
-		OptionReducer(Some(self.0.make()))
-	}
-}
-
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-pub struct OptionReducer<R>(#[pin] Option<R>);
-impl<R> Default for OptionReducer<R>
+impl<R: ReducerAsync<Item>, T, Item> ReducerAsync<Item> for IntoReducerAsync<R, T>
 where
-	R: Default,
+	R::Output: Into<T>,
 {
-	fn default() -> Self {
-		Self(Some(R::default()))
+	type Output = T;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.project().0.output().await.into() })
 	}
 }
-impl<R: Reducer> Reducer for OptionReducer<R> {
-	type Item = Option<R::Item>;
+
+#[derive(Clone, Default, Serialize, Deserialize)]
+pub struct OptionReducer<R>(R);
+impl<R: Reducer<Item>, Item> Reducer<Option<Item>> for OptionReducer<R> {
 	type Output = Option<R::Output>;
-	type Async = OptionReducer<R::Async>;
+	type Async = OptionReducerAsync<R::Async>;
 
 	fn into_async(self) -> Self::Async {
-		OptionReducer(Some(self.0.unwrap().into_async()))
+		OptionReducerAsync(Some(self.0.into_async()))
 	}
 }
-impl<R: ReducerAsync> ReducerAsync for OptionReducer<R> {
-	type Item = Option<R::Item>;
+impl<R: Reducer<Item>, Item> ReducerProcessSend<Option<Item>> for OptionReducer<R>
+where
+	R::Output: ProcessSend + 'static,
+{
 	type Output = Option<R::Output>;
+}
+impl<R: Reducer<Item>, Item> ReducerSend<Option<Item>> for OptionReducer<R>
+where
+	R::Output: Send + 'static,
+{
+	type Output = Option<R::Output>;
+}
+
+#[pin_project]
+pub struct OptionReducerAsync<R>(#[pin] Option<R>);
 
+impl<R: ReducerAsync<Item>, Item> Sink<Option<Item>> for OptionReducerAsync<R> {
 	#[inline]
-	fn poll_forward(
-		self: Pin<&mut Self>, _cx: &mut Context, _stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, _cx: &mut Context,
+		_stream: Pin<&mut impl Stream<Item = Option<Item>>>,
 	) -> Poll<()> {
 		todo!("Tracking at https://github.com/constellation-rs/amadeus/projects/3#card-40276549");
 		// let self_ = self.project();
@@ -307,83 +253,56 @@ impl<R: ReducerAsync> ReducerAsync for OptionReducer<R> {
 		// }
 		// self_.0.is_some()
 	}
-	fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		self.project()
-			.0
-			.as_pin_mut()
-			.map(|r| r.poll_output(cx).map(Some))
-			.unwrap_or(Poll::Ready(None))
-	}
 }
-impl<R: Reducer> ReducerProcessSend for OptionReducer<R>
-where
-	R::Output: ProcessSend + 'static,
-{
-	type Output = Option<R::Output>;
-}
-impl<R: Reducer> ReducerSend for OptionReducer<R>
-where
-	R::Output: Send + 'static,
-{
+impl<R: ReducerAsync<Item>, Item> ReducerAsync<Option<Item>> for OptionReducerAsync<R> {
 	type Output = Option<R::Output>;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { Some(self.project().0.as_pin_mut()?.output().await) })
+	}
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone(bound = "R: Clone"), Default(bound = "R: Default"))]
 #[serde(
-	bound(serialize = "RF: Serialize"),
-	bound(deserialize = "RF: Deserialize<'de>")
+	bound(serialize = "R: Serialize"),
+	bound(deserialize = "R: Deserialize<'de>")
 )]
-pub struct ResultReducerFactory<RF, E>(RF, PhantomData<fn() -> E>);
-impl<RF, E> Factory for ResultReducerFactory<RF, E>
-where
-	RF: Factory,
-{
-	type Item = ResultReducer<RF::Item, E>;
+pub struct ResultReducer<R, E>(R, PhantomData<fn() -> E>);
 
-	fn make(&self) -> Self::Item {
-		ResultReducer(self.0.make(), PhantomData)
+impl<R: Reducer<Item>, E, Item> Reducer<Result<Item, E>> for ResultReducer<R, E> {
+	type Output = Result<R::Output, E>;
+	type Async = ResultReducerAsync<R::Async, E>;
+
+	fn into_async(self) -> Self::Async {
+		ResultReducerAsync::Ok(self.0.into_async())
 	}
 }
-impl<RF, E> Clone for ResultReducerFactory<RF, E>
+impl<R: Reducer<Item>, E, Item> ReducerProcessSend<Result<Item, E>> for ResultReducer<R, E>
 where
-	RF: Clone,
+	R::Output: ProcessSend + 'static,
+	E: ProcessSend + 'static,
 {
-	fn clone(&self) -> Self {
-		Self(self.0.clone(), PhantomData)
-	}
+	type Output = Result<R::Output, E>;
 }
-
-#[derive(Serialize, Deserialize)]
-pub struct ResultReducer<R, E>(R, PhantomData<fn() -> E>);
-impl<R, E> Default for ResultReducer<R, E>
+impl<R: Reducer<Item>, E, Item> ReducerSend<Result<Item, E>> for ResultReducer<R, E>
 where
-	R: Default,
+	R::Output: Send + 'static,
+	E: Send + 'static,
 {
-	fn default() -> Self {
-		Self(R::default(), PhantomData)
-	}
-}
-impl<R: Reducer, E> Reducer for ResultReducer<R, E> {
-	type Item = Result<R::Item, E>;
 	type Output = Result<R::Output, E>;
-	type Async = ResultReducerAsync<R::Async, E>;
-
-	fn into_async(self) -> Self::Async {
-		ResultReducerAsync::Ok(self.0.into_async())
-	}
 }
+
 #[pin_project(project = ResultReducerAsyncProj)]
 pub enum ResultReducerAsync<R, E> {
 	Ok(#[pin] R),
 	Err(Option<E>),
 }
-impl<R: ReducerAsync, E> ReducerAsync for ResultReducerAsync<R, E> {
-	type Item = Result<R::Item, E>;
-	type Output = Result<R::Output, E>;
-
+impl<R: ReducerAsync<Item>, E, Item> Sink<Result<Item, E>> for ResultReducerAsync<R, E> {
 	#[inline]
-	fn poll_forward(
-		self: Pin<&mut Self>, _cx: &mut Context, _stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, _cx: &mut Context,
+		_stream: Pin<&mut impl Stream<Item = Result<Item, E>>>,
 	) -> Poll<()> {
 		todo!("Tracking at https://github.com/constellation-rs/amadeus/projects/3#card-40276549");
 		// let self_ = self.project();
@@ -396,37 +315,28 @@ impl<R: ReducerAsync, E> ReducerAsync for ResultReducerAsync<R, E> {
 		// }
 		// self_.0.is_ok()
 	}
-	fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		match self.project() {
-			ResultReducerAsyncProj::Ok(a) => a.poll_output(cx).map(Ok),
-			ResultReducerAsyncProj::Err(b) => Poll::Ready(Err(b.take().unwrap())),
-		}
-	}
 }
-impl<R: Reducer, E> ReducerProcessSend for ResultReducer<R, E>
-where
-	R::Output: ProcessSend + 'static,
-	E: ProcessSend + 'static,
-{
-	type Output = Result<R::Output, E>;
-}
-impl<R: Reducer, E> ReducerSend for ResultReducer<R, E>
-where
-	R::Output: Send + 'static,
-	E: Send + 'static,
-{
+impl<R: ReducerAsync<Item>, E, Item> ReducerAsync<Result<Item, E>> for ResultReducerAsync<R, E> {
 	type Output = Result<R::Output, E>;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move {
+			match self.project() {
+				ResultReducerAsyncProj::Ok(a) => Ok(a.output().await),
+				ResultReducerAsyncProj::Err(b) => Err(b.take().unwrap()),
+			}
+		})
+	}
 }
 
 impl<T> FromParallelStream<T> for Vec<T>
 where
 	T: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -435,11 +345,10 @@ impl<T> FromParallelStream<T> for VecDeque<T>
 where
 	T: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Vec<T>>;
 	type ReduceC = IntoReducer<ExtendReducer<Vec<T>>, Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -448,11 +357,10 @@ impl<T: Ord> FromParallelStream<T> for BinaryHeap<T>
 where
 	T: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Vec<T>>;
 	type ReduceC = IntoReducer<ExtendReducer<Vec<T>>, Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -461,11 +369,10 @@ impl<T> FromParallelStream<T> for LinkedList<T>
 where
 	T: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -475,11 +382,10 @@ where
 	T: Eq + Hash + Send + 'static,
 	S: BuildHasher + Default + Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -490,11 +396,10 @@ where
 	V: Send + 'static,
 	S: BuildHasher + Default + Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<(K, V), Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -503,11 +408,10 @@ impl<T> FromParallelStream<T> for BTreeSet<T>
 where
 	T: Ord + Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -517,53 +421,48 @@ where
 	K: Ord + Send + 'static,
 	V: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<(K, V), Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromParallelStream<char> for String {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<char, Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromParallelStream<Self> for String {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromParallelStream<()> for () {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl<T, C: FromParallelStream<T>> FromParallelStream<Option<T>> for Option<C> {
-	type ReduceAFactory = OptionReducerFactory<C::ReduceAFactory>;
 	type ReduceA = OptionReducer<C::ReduceA>;
 	type ReduceC = OptionReducer<C::ReduceC>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		let (a, c) = C::reducers();
-		(OptionReducerFactory(a), OptionReducer(Some(c)))
+		(OptionReducer(a), OptionReducer(c))
 	}
 }
 
@@ -571,16 +470,12 @@ impl<T, C: FromParallelStream<T>, E> FromParallelStream<Result<T, E>> for Result
 where
 	E: Send + 'static,
 {
-	type ReduceAFactory = ResultReducerFactory<C::ReduceAFactory, E>;
 	type ReduceA = ResultReducer<C::ReduceA, E>;
 	type ReduceC = ResultReducer<C::ReduceC, E>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		let (a, c) = C::reducers();
-		(
-			ResultReducerFactory(a, PhantomData),
-			ResultReducer(c, PhantomData),
-		)
+		(ResultReducer(a, PhantomData), ResultReducer(c, PhantomData))
 	}
 }
 
@@ -588,13 +483,11 @@ impl<T> FromDistributedStream<T> for Vec<T>
 where
 	T: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -603,13 +496,11 @@ impl<T> FromDistributedStream<T> for VecDeque<T>
 where
 	T: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Vec<T>>;
 	type ReduceB = ExtendReducer<Vec<T>>;
 	type ReduceC = IntoReducer<ExtendReducer<Vec<T>>, Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -618,13 +509,11 @@ impl<T: Ord> FromDistributedStream<T> for BinaryHeap<T>
 where
 	T: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Vec<T>>;
 	type ReduceB = ExtendReducer<Vec<T>>;
 	type ReduceC = IntoReducer<ExtendReducer<Vec<T>>, Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -633,13 +522,11 @@ impl<T> FromDistributedStream<T> for LinkedList<T>
 where
 	T: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -649,13 +536,11 @@ where
 	T: Eq + Hash + ProcessSend + 'static,
 	S: BuildHasher + Default + Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -666,13 +551,11 @@ where
 	V: ProcessSend + 'static,
 	S: BuildHasher + Default + Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<(K, V), Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -681,13 +564,11 @@ impl<T> FromDistributedStream<T> for BTreeSet<T>
 where
 	T: Ord + ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -697,67 +578,53 @@ where
 	K: Ord + ProcessSend + 'static,
 	V: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<(K, V), Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromDistributedStream<char> for String {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<char, Self>;
 	type ReduceB = PushReducer<Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromDistributedStream<Self> for String {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<Self>;
 	type ReduceB = PushReducer<Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl FromDistributedStream<()> for () {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<Self>;
 	type ReduceB = PushReducer<Self>;
 	type ReduceC = PushReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
 
 impl<T, C: FromDistributedStream<T>> FromDistributedStream<Option<T>> for Option<C> {
-	type ReduceAFactory = OptionReducerFactory<C::ReduceAFactory>;
-	type ReduceBFactory = OptionReducerFactory<C::ReduceBFactory>;
 	type ReduceA = OptionReducer<C::ReduceA>;
 	type ReduceB = OptionReducer<C::ReduceB>;
 	type ReduceC = OptionReducer<C::ReduceC>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		let (a, b, c) = C::reducers();
-		(
-			OptionReducerFactory(a),
-			OptionReducerFactory(b),
-			OptionReducer(Some(c)),
-		)
+		(OptionReducer(a), OptionReducer(b), OptionReducer(c))
 	}
 }
 
@@ -765,17 +632,15 @@ impl<T, C: FromDistributedStream<T>, E> FromDistributedStream<Result<T, E>> for
 where
 	E: ProcessSend + 'static,
 {
-	type ReduceAFactory = ResultReducerFactory<C::ReduceAFactory, E>;
-	type ReduceBFactory = ResultReducerFactory<C::ReduceBFactory, E>;
 	type ReduceA = ResultReducer<C::ReduceA, E>;
 	type ReduceB = ResultReducer<C::ReduceB, E>;
 	type ReduceC = ResultReducer<C::ReduceC, E>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		let (a, b, c) = C::reducers();
 		(
-			ResultReducerFactory(a, PhantomData),
-			ResultReducerFactory(b, PhantomData),
+			ResultReducer(a, PhantomData),
+			ResultReducer(b, PhantomData),
 			ResultReducer(c, PhantomData),
 		)
 	}
diff --git a/amadeus-core/src/par_sink/combine.rs b/amadeus-core/src/par_sink/combine.rs
index ef12cb40..b0c255f0 100644
--- a/amadeus-core/src/par_sink/combine.rs
+++ b/amadeus-core/src/par_sink/combine.rs
@@ -3,9 +3,7 @@ use educe::Educe;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 
-use super::{
-	combiner_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
-};
+use super::{combiner_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink};
 
 #[derive(Educe, Serialize, Deserialize, new)]
 #[educe(Clone(bound = "F: Clone"))]
diff --git a/amadeus-core/src/par_sink/combiner.rs b/amadeus-core/src/par_sink/combiner.rs
index c81cb20d..92b2f6d8 100644
--- a/amadeus-core/src/par_sink/combiner.rs
+++ b/amadeus-core/src/par_sink/combiner.rs
@@ -1,52 +1,51 @@
+#![allow(unused_imports,clippy::single_component_path_imports)]
+
 use super::FolderSync;
 
 mod macros {
 	#[macro_export]
-	macro_rules! combiner_dist_sink {
+	macro_rules! combiner_par_sink {
 		($combiner:ty, $self:ident, $init:expr) => {
-			type Output = <Self::ReduceC as $crate::par_sink::Reducer>::Output;
+			type Output = <Self::ReduceC as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output;
 			type Pipe = I;
-			type ReduceAFactory = FolderSyncReducerFactory<I::Item, $combiner>;
-			type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $combiner>;
 			type ReduceA = FolderSyncReducer<I::Item, $combiner>;
-			type ReduceB = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $combiner>;
-			type ReduceC = FolderSyncReducer<<Self::ReduceB as $crate::par_sink::Reducer>::Output, $combiner>;
+			type ReduceC = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output, $combiner>;
 
-			fn reducers($self) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+			fn reducers($self) -> (I, Self::ReduceA, Self::ReduceC) {
 				let init = $init;
 				(
 					$self.i,
-					FolderSyncReducerFactory::new(init.clone()),
-					FolderSyncReducerFactory::new(init.clone()),
+					FolderSyncReducer::new(init.clone()),
 					FolderSyncReducer::new(init),
 				)
 			}
 		};
 	}
 	#[macro_export]
-	macro_rules! combiner_par_sink {
+	macro_rules! combiner_dist_sink {
 		($combiner:ty, $self:ident, $init:expr) => {
-			type Output = <Self::ReduceC as $crate::par_sink::Reducer>::Output;
+			type Output = <Self::ReduceC as $crate::par_sink::Reducer<<Self::ReduceB as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output>>::Output;
 			type Pipe = I;
-			type ReduceAFactory = FolderSyncReducerFactory<I::Item, $combiner>;
 			type ReduceA = FolderSyncReducer<I::Item, $combiner>;
-			type ReduceC = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $combiner>;
+			type ReduceB = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output, $combiner>;
+			type ReduceC = FolderSyncReducer<<Self::ReduceB as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output, $combiner>;
 
-			fn reducers($self) -> (I, Self::ReduceAFactory, Self::ReduceC) {
+			fn reducers($self) -> (I, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 				let init = $init;
 				(
 					$self.i,
-					FolderSyncReducerFactory::new(init.clone()),
+					FolderSyncReducer::new(init.clone()),
+					FolderSyncReducer::new(init.clone()),
 					FolderSyncReducer::new(init),
 				)
 			}
 		};
 	}
-	pub use combiner_dist_sink;
-	pub use combiner_par_sink;
+	pub(crate) use combiner_dist_sink;
+	pub(crate) use combiner_par_sink;
 }
 
-pub use macros::{combiner_dist_sink, combiner_par_sink};
+pub(crate) use macros::{combiner_dist_sink, combiner_par_sink};
 
 pub trait CombinerSync {
 	type Output;
diff --git a/amadeus-core/src/par_sink/count.rs b/amadeus-core/src/par_sink/count.rs
index 005206b1..128496b0 100644
--- a/amadeus-core/src/par_sink/count.rs
+++ b/amadeus-core/src/par_sink/count.rs
@@ -2,7 +2,7 @@ use derive_new::new;
 use serde::{Deserialize, Serialize};
 
 use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink, SumFolder
+	folder_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink, SumFolder
 };
 
 #[derive(new)]
diff --git a/amadeus-core/src/par_sink/fold.rs b/amadeus-core/src/par_sink/fold.rs
index 7e29bead..c568d5bc 100644
--- a/amadeus-core/src/par_sink/fold.rs
+++ b/amadeus-core/src/par_sink/fold.rs
@@ -7,9 +7,7 @@ use replace_with::replace_with_or_abort;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 
-use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
-};
+use super::{folder_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink};
 
 #[derive(new)]
 #[must_use]
diff --git a/amadeus-core/src/par_sink/folder.rs b/amadeus-core/src/par_sink/folder.rs
index 20515984..0fef0d84 100644
--- a/amadeus-core/src/par_sink/folder.rs
+++ b/amadeus-core/src/par_sink/folder.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::type_complexity)]
+#![allow(unused_imports,clippy::single_component_path_imports)]
 
 use derive_new::new;
 use educe::Educe;
@@ -6,28 +6,27 @@ use futures::{ready, Stream};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	marker::PhantomData, pin::Pin, task::{Context, Poll}
+	future::Future, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
-use super::{Factory, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend};
-use crate::pool::ProcessSend;
+use super::{Reducer, ReducerAsync, ReducerProcessSend, ReducerSend};
+use crate::{pipe::Sink, pool::ProcessSend};
 
 mod macros {
 	#[macro_export]
 	macro_rules! folder_par_sink {
 		($folder_a:ty, $folder_b:ty, $self:ident, $init_a:expr, $init_b:expr) => {
-			type Output = <Self::ReduceC as $crate::par_sink::Reducer>::Output;
+			type Output = <Self::ReduceC as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output;
 			type Pipe = I;
-			type ReduceAFactory = FolderSyncReducerFactory<I::Item, $folder_a>;
 			type ReduceA = FolderSyncReducer<I::Item, $folder_a>;
-			type ReduceC = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $folder_b>;
+			type ReduceC = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output, $folder_b>;
 
-			fn reducers($self) -> (I, Self::ReduceAFactory, Self::ReduceC) {
+			fn reducers($self) -> (I, Self::ReduceA, Self::ReduceC) {
 				let init_a = $init_a;
 				let init_b = $init_b;
 				(
 					$self.i,
-					FolderSyncReducerFactory::new(init_a),
+					FolderSyncReducer::new(init_a),
 					FolderSyncReducer::new(init_b),
 				)
 			}
@@ -36,31 +35,29 @@ mod macros {
 	#[macro_export]
 	macro_rules! folder_dist_sink {
 		($folder_a:ty, $folder_b:ty, $self:ident, $init_a:expr, $init_b:expr) => {
-			type Output = <Self::ReduceC as $crate::par_sink::Reducer>::Output;
+			type Output = <Self::ReduceC as $crate::par_sink::Reducer<<Self::ReduceB as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output>>::Output;
 			type Pipe = I;
-			type ReduceAFactory = FolderSyncReducerFactory<I::Item, $folder_a>;
-			type ReduceBFactory = FolderSyncReducerFactory<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $folder_b>;
 			type ReduceA = FolderSyncReducer<I::Item, $folder_a>;
-			type ReduceB = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer>::Output, $folder_b>;
-			type ReduceC = FolderSyncReducer<<Self::ReduceB as $crate::par_sink::Reducer>::Output, $folder_b>;
+			type ReduceB = FolderSyncReducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output, $folder_b>;
+			type ReduceC = FolderSyncReducer<<Self::ReduceB as $crate::par_sink::Reducer<<Self::ReduceA as $crate::par_sink::Reducer<I::Item>>::Output>>::Output, $folder_b>;
 
-			fn reducers($self) -> (I, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+			fn reducers($self) -> (I, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 				let init_a = $init_a;
 				let init_b = $init_b;
 				(
 					$self.i,
-					FolderSyncReducerFactory::new(init_a),
-					FolderSyncReducerFactory::new(init_b.clone()),
+					FolderSyncReducer::new(init_a),
+					FolderSyncReducer::new(init_b.clone()),
 					FolderSyncReducer::new(init_b),
 				)
 			}
 		};
 	}
-	pub use folder_dist_sink;
-	pub use folder_par_sink;
+	pub(crate) use folder_dist_sink;
+	pub(crate) use folder_par_sink;
 }
 
-pub use macros::{folder_dist_sink, folder_par_sink};
+pub(crate) use macros::{folder_dist_sink, folder_par_sink};
 
 pub trait FolderSync<A> {
 	type Output;
@@ -69,30 +66,6 @@ pub trait FolderSync<A> {
 	fn push(&mut self, state: &mut Self::Output, item: A);
 }
 
-#[derive(Educe, Serialize, Deserialize, new)]
-#[educe(Clone(bound = "C: Clone"))]
-#[serde(
-	bound(serialize = "C: Serialize"),
-	bound(deserialize = "C: Deserialize<'de>")
-)]
-pub struct FolderSyncReducerFactory<A, C> {
-	folder: C,
-	marker: PhantomData<fn() -> A>,
-}
-impl<A, C> Factory for FolderSyncReducerFactory<A, C>
-where
-	C: FolderSync<A> + Clone,
-{
-	type Item = FolderSyncReducer<A, C>;
-
-	fn make(&self) -> Self::Item {
-		FolderSyncReducer {
-			folder: self.folder.clone(),
-			marker: PhantomData,
-		}
-	}
-}
-
 #[derive(Educe, Serialize, Deserialize, new)]
 #[educe(Clone(bound = "C: Clone"))]
 #[serde(
@@ -104,11 +77,10 @@ pub struct FolderSyncReducer<A, C> {
 	marker: PhantomData<fn() -> A>,
 }
 
-impl<A, C> Reducer for FolderSyncReducer<A, C>
+impl<A, C> Reducer<A> for FolderSyncReducer<A, C>
 where
 	C: FolderSync<A>,
 {
-	type Item = A;
 	type Output = C::Output;
 	type Async = FolderSyncReducerAsync<A, C, C::Output>;
 
@@ -120,6 +92,20 @@ where
 		}
 	}
 }
+impl<A, C> ReducerProcessSend<A> for FolderSyncReducer<A, C>
+where
+	C: FolderSync<A>,
+	C::Output: ProcessSend + 'static,
+{
+	type Output = C::Output;
+}
+impl<A, C> ReducerSend<A> for FolderSyncReducer<A, C>
+where
+	C: FolderSync<A>,
+	C::Output: Send + 'static,
+{
+	type Output = C::Output;
+}
 
 #[pin_project]
 pub struct FolderSyncReducerAsync<A, C, D> {
@@ -127,17 +113,13 @@ pub struct FolderSyncReducerAsync<A, C, D> {
 	folder: C,
 	marker: PhantomData<fn() -> A>,
 }
-impl<A, C> ReducerAsync for FolderSyncReducerAsync<A, C, C::Output>
+impl<A, C> Sink<A> for FolderSyncReducerAsync<A, C, C::Output>
 where
 	C: FolderSync<A>,
 {
-	type Item = A;
-	type Output = C::Output;
-
 	#[inline(always)]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		let folder = self_.folder;
@@ -146,21 +128,14 @@ where
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(self.project().state.take().unwrap())
-	}
-}
-impl<A, C> ReducerProcessSend for FolderSyncReducer<A, C>
-where
-	C: FolderSync<A>,
-	C::Output: ProcessSend + 'static,
-{
-	type Output = C::Output;
 }
-impl<A, C> ReducerSend for FolderSyncReducer<A, C>
+impl<A, C> ReducerAsync<A> for FolderSyncReducerAsync<A, C, C::Output>
 where
 	C: FolderSync<A>,
-	C::Output: Send + 'static,
 {
 	type Output = C::Output;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move { self.project().state.take().unwrap() })
+	}
 }
diff --git a/amadeus-core/src/par_sink/for_each.rs b/amadeus-core/src/par_sink/for_each.rs
index aebc2dce..302972d4 100644
--- a/amadeus-core/src/par_sink/for_each.rs
+++ b/amadeus-core/src/par_sink/for_each.rs
@@ -1,15 +1,16 @@
 use derive_new::new;
+use educe::Educe;
 use futures::{ready, Stream};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	marker::PhantomData, pin::Pin, task::{Context, Poll}
+	future::Future, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
 use super::{
-	DefaultReducerFactory, DistributedPipe, DistributedSink, Factory, ParallelPipe, ParallelSink, PushReducer, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PushReducer, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
 };
-use crate::pool::ProcessSend;
+use crate::{pipe::Sink, pool::ProcessSend};
 
 #[derive(new)]
 #[must_use]
@@ -18,90 +19,56 @@ pub struct ForEach<I, F> {
 	f: F,
 }
 
-impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for ForEach<I, F>
+impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for ForEach<I, F>
 where
-	F: FnMut(I::Item) + Clone + ProcessSend + 'static,
+	F: FnMut(I::Item) + Clone + Send + 'static,
 {
 	type Output = ();
 	type Pipe = I;
-	type ReduceAFactory = ForEachReducerFactory<I::Item, F>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = ForEachReducer<I::Item, F>;
-	type ReduceB = PushReducer<()>;
 	type ReduceC = PushReducer<()>;
 
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
 		(
 			self.i,
-			ForEachReducerFactory(self.f, PhantomData),
-			DefaultReducerFactory::new(),
-			PushReducer::new(()),
+			ForEachReducer(self.f, PhantomData),
+			PushReducer::new(),
 		)
 	}
 }
-impl<I: ParallelPipe<Source>, Source, F> ParallelSink<Source> for ForEach<I, F>
+impl<I: DistributedPipe<Source>, Source, F> DistributedSink<Source> for ForEach<I, F>
 where
-	F: FnMut(I::Item) + Clone + Send + 'static,
+	F: FnMut(I::Item) + Clone + ProcessSend + 'static,
 {
 	type Output = ();
 	type Pipe = I;
-	type ReduceAFactory = ForEachReducerFactory<I::Item, F>;
 	type ReduceA = ForEachReducer<I::Item, F>;
+	type ReduceB = PushReducer<()>;
 	type ReduceC = PushReducer<()>;
 
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		(
 			self.i,
-			ForEachReducerFactory(self.f, PhantomData),
-			PushReducer::new(()),
+			ForEachReducer(self.f, PhantomData),
+			PushReducer::new(),
+			PushReducer::new(),
 		)
 	}
 }
 
-#[derive(Serialize, Deserialize)]
-#[serde(
-	bound(serialize = "F: Serialize"),
-	bound(deserialize = "F: Deserialize<'de>")
-)]
-pub struct ForEachReducerFactory<A, F>(F, PhantomData<fn() -> A>);
-impl<A, F> Factory for ForEachReducerFactory<A, F>
-where
-	F: FnMut(A) + Clone,
-{
-	type Item = ForEachReducer<A, F>;
-	fn make(&self) -> Self::Item {
-		ForEachReducer(self.0.clone(), PhantomData)
-	}
-}
-impl<A, F> Clone for ForEachReducerFactory<A, F>
-where
-	F: Clone,
-{
-	fn clone(&self) -> Self {
-		Self(self.0.clone(), PhantomData)
-	}
-}
-
 #[pin_project]
-#[derive(Serialize, Deserialize)]
+#[derive(Educe, Serialize, Deserialize)]
+#[educe(Clone(bound = "F: Clone"))]
 #[serde(
 	bound(serialize = "F: Serialize"),
 	bound(deserialize = "F: Deserialize<'de>")
 )]
 pub struct ForEachReducer<A, F>(F, PhantomData<fn() -> A>);
 
-impl<A, F> Reducer for ForEachReducer<A, F>
+impl<A, F> Reducer<A> for ForEachReducer<A, F>
 where
 	F: FnMut(A) + Clone,
 {
-	type Item = A;
 	type Output = ();
 	type Async = Self;
 
@@ -109,17 +76,26 @@ where
 		self
 	}
 }
-impl<A, F> ReducerAsync for ForEachReducer<A, F>
+impl<A, F> ReducerProcessSend<A> for ForEachReducer<A, F>
 where
 	F: FnMut(A) + Clone,
 {
-	type Item = A;
 	type Output = ();
+}
+impl<A, F> ReducerSend<A> for ForEachReducer<A, F>
+where
+	F: FnMut(A) + Clone,
+{
+	type Output = ();
+}
 
+impl<A, F> Sink<A> for ForEachReducer<A, F>
+where
+	F: FnMut(A) + Clone,
+{
 	#[inline(always)]
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = A>>,
 	) -> Poll<()> {
 		let self_ = self.project();
 		while let Some(item) = ready!(stream.as_mut().poll_next(cx)) {
@@ -127,19 +103,14 @@ where
 		}
 		Poll::Ready(())
 	}
-	fn poll_output(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-		Poll::Ready(())
-	}
-}
-impl<A, F> ReducerProcessSend for ForEachReducer<A, F>
-where
-	F: FnMut(A) + Clone,
-{
-	type Output = ();
 }
-impl<A, F> ReducerSend for ForEachReducer<A, F>
+impl<A, F> ReducerAsync<A> for ForEachReducer<A, F>
 where
 	F: FnMut(A) + Clone,
 {
 	type Output = ();
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move {})
+	}
 }
diff --git a/amadeus-core/src/par_sink/fork.rs b/amadeus-core/src/par_sink/fork.rs
new file mode 100644
index 00000000..f6d3ff50
--- /dev/null
+++ b/amadeus-core/src/par_sink/fork.rs
@@ -0,0 +1,304 @@
+// TODO: document why this is sound
+#![allow(unsafe_code)]
+
+use derive_new::new;
+use futures::{pin_mut, stream, Stream, StreamExt as _};
+use pin_project::pin_project;
+use serde::{Deserialize, Serialize};
+use std::{
+	marker::PhantomData, pin::Pin, task::{Context, Poll}
+};
+use sum::Sum2;
+
+use super::{
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PipeTask, ReduceA2, ReduceC2
+};
+use crate::{
+	par_stream::{ParallelStream, StreamTask}, pipe::Pipe, util::transmute
+};
+
+#[derive(new)]
+#[must_use]
+pub struct Fork<A, B, C, RefAItem> {
+	a: A,
+	b: B,
+	c: C,
+	marker: PhantomData<fn() -> RefAItem>,
+}
+
+impl_par_dist! {
+	impl<A, B, C, RefAItem> ParallelStream for Fork<A, B, C, RefAItem>
+	where
+		A: ParallelStream,
+		B: ParallelPipe<A::Item>,
+		C: ParallelPipe<RefAItem>,
+		RefAItem: 'static,
+	{
+		type Item = Sum2<B::Item, C::Item>;
+		type Task = JoinTask<A::Task, B::Task, C::Task, RefAItem>;
+
+		fn size_hint(&self) -> (usize, Option<usize>) {
+			self.a.size_hint()
+		}
+		fn next_task(&mut self) -> Option<Self::Task> {
+			self.a
+				.next_task()
+				.map(|task| JoinTask{stream:task, pipe:self.b.task(), pipe_ref:self.c.task(), marker:PhantomData})
+		}
+	}
+	impl<A,B,C, Source, RefAItem> ParallelPipe<Source> for Fork<A, B, C, RefAItem>
+	where
+		A: ParallelPipe<Source>,
+		B: ParallelPipe<A::Item>,
+		C: ParallelPipe<RefAItem>,
+		RefAItem: 'static,
+	{
+		type Item = Sum2<B::Item, C::Item>;
+		type Task = JoinTask<A::Task, B::Task, C::Task, RefAItem>;
+
+		fn task(&self) -> Self::Task {
+			let stream = self.a.task();
+			let pipe = self.b.task();
+			let pipe_ref = self.c.task();
+			JoinTask { stream, pipe, pipe_ref, marker: PhantomData }
+		}
+	}
+}
+
+impl<A, B, C, Source, RefAItem> ParallelSink<Source> for Fork<A, B, C, RefAItem>
+where
+	A: ParallelPipe<Source>,
+	B: ParallelSink<A::Item>,
+	C: ParallelSink<RefAItem>,
+	RefAItem: 'static,
+{
+	type Output = (B::Output, C::Output);
+	type Pipe = Fork<A, B::Pipe, C::Pipe, RefAItem>;
+	type ReduceA = ReduceA2<B::ReduceA, C::ReduceA>;
+	type ReduceC = ReduceC2<B::ReduceC, C::ReduceC>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
+		let (iterator_a, reducer_a_a, reducer_a_c) = self.b.reducers();
+		let (iterator_b, reducer_b_a, reducer_b_c) = self.c.reducers();
+		(
+			Fork::new(self.a, iterator_a, iterator_b),
+			ReduceA2::new(reducer_a_a, reducer_b_a),
+			ReduceC2::new(reducer_a_c, reducer_b_c),
+		)
+	}
+}
+impl<A, B, C, Source, RefAItem> DistributedSink<Source> for Fork<A, B, C, RefAItem>
+where
+	A: DistributedPipe<Source>,
+	B: DistributedSink<A::Item>,
+	C: DistributedSink<RefAItem>,
+	RefAItem: 'static,
+{
+	type Output = (B::Output, C::Output);
+	type Pipe = Fork<A, B::Pipe, C::Pipe, RefAItem>;
+	type ReduceA = ReduceA2<B::ReduceA, C::ReduceA>;
+	type ReduceB = ReduceC2<B::ReduceB, C::ReduceB>;
+	type ReduceC = ReduceC2<B::ReduceC, C::ReduceC>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
+		let (iterator_a, reducer_a_a, reducer_a_b, reducer_a_c) = self.b.reducers();
+		let (iterator_b, reducer_b_a, reducer_b_b, reducer_b_c) = self.c.reducers();
+		(
+			Fork::new(self.a, iterator_a, iterator_b),
+			ReduceA2::new(reducer_a_a, reducer_b_a),
+			ReduceC2::new(reducer_a_b, reducer_b_b),
+			ReduceC2::new(reducer_a_c, reducer_b_c),
+		)
+	}
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(
+	bound(serialize = "A: Serialize, B: Serialize, C: Serialize"),
+	bound(deserialize = "A: Deserialize<'de>, B: Deserialize<'de>, C: Deserialize<'de>")
+)]
+pub struct JoinTask<A, B, C, RefAItem> {
+	stream: A,
+	pipe: B,
+	pipe_ref: C,
+	marker: PhantomData<fn() -> RefAItem>,
+}
+impl<A, B, C, RefAItem> StreamTask for JoinTask<A, B, C, RefAItem>
+where
+	A: StreamTask,
+	B: PipeTask<A::Item>,
+	C: PipeTask<RefAItem>,
+{
+	type Item = Sum2<B::Item, C::Item>;
+	type Async = JoinStreamTaskAsync<A::Async, B::Async, C::Async, RefAItem, A::Item>;
+
+	fn into_async(self) -> Self::Async {
+		JoinStreamTaskAsync {
+			stream: self.stream.into_async(),
+			pipe: self.pipe.into_async(),
+			pipe_ref: self.pipe_ref.into_async(),
+			ref_given: false,
+			pending: None,
+			marker: PhantomData,
+		}
+	}
+}
+impl<A, B, C, Source, RefAItem> PipeTask<Source> for JoinTask<A, B, C, RefAItem>
+where
+	A: PipeTask<Source>,
+	B: PipeTask<A::Item>,
+	C: PipeTask<RefAItem>,
+{
+	type Item = Sum2<B::Item, C::Item>;
+	type Async = JoinStreamTaskAsync<A::Async, B::Async, C::Async, RefAItem, A::Item>;
+
+	fn into_async(self) -> Self::Async {
+		JoinStreamTaskAsync {
+			stream: self.stream.into_async(),
+			pipe: self.pipe.into_async(),
+			pipe_ref: self.pipe_ref.into_async(),
+			ref_given: false,
+			pending: None,
+			marker: PhantomData,
+		}
+	}
+}
+
+#[pin_project]
+pub struct JoinStreamTaskAsync<A, B, C, RefAItem, T> {
+	#[pin]
+	stream: A,
+	#[pin]
+	pipe: B,
+	#[pin]
+	pipe_ref: C,
+	ref_given: bool,
+	pending: Option<Option<T>>,
+	marker: PhantomData<fn() -> RefAItem>,
+}
+
+impl<A, B, C, RefAItem> Stream for JoinStreamTaskAsync<A, B, C, RefAItem, A::Item>
+where
+	A: Stream,
+	B: Pipe<A::Item>,
+	C: Pipe<RefAItem>,
+{
+	type Item = Sum2<B::Item, C::Item>;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		loop {
+			if self_.pending.is_none() {
+				*self_.pending = match self_.stream.as_mut().poll_next(cx) {
+					Poll::Ready(x) => Some(x),
+					Poll::Pending => None,
+				};
+			}
+			let ref_given = &mut *self_.ref_given;
+			let pending = &mut *self_.pending;
+			let mut progress = false;
+			{
+				let stream = stream::poll_fn(|_cx| match pending {
+					Some(x) if !*ref_given => {
+						*ref_given = true;
+						progress = true;
+						Poll::Ready(unsafe { transmute(x.as_ref()) })
+					}
+					_ => Poll::Pending,
+				})
+				.fuse();
+				pin_mut!(stream);
+				if let Poll::Ready(item) = self_.pipe_ref.as_mut().poll_next(cx, stream) {
+					return Poll::Ready(item.map(|item| Sum2::B(unsafe { transmute(item) })));
+				}
+			}
+			{
+				let stream = stream::poll_fn(|_cx| {
+					if !*ref_given {
+						return Poll::Pending;
+					}
+					match pending.take() {
+						Some(x) => {
+							*ref_given = false;
+							progress = true;
+							Poll::Ready(x)
+						}
+						None => Poll::Pending,
+					}
+				})
+				.fuse();
+				pin_mut!(stream);
+				if let Poll::Ready(item) = self_.pipe.as_mut().poll_next(cx, stream) {
+					return Poll::Ready(item.map(Sum2::A));
+				}
+			}
+			if !progress {
+				break Poll::Pending;
+			}
+		}
+	}
+}
+
+impl<A, B, C, Source, RefAItem> Pipe<Source> for JoinStreamTaskAsync<A, B, C, RefAItem, A::Item>
+where
+	A: Pipe<Source>,
+	B: Pipe<A::Item>,
+	C: Pipe<RefAItem>,
+{
+	type Item = Sum2<B::Item, C::Item>;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		loop {
+			if self_.pending.is_none() {
+				*self_.pending = match self_.stream.as_mut().poll_next(cx, stream.as_mut()) {
+					Poll::Ready(x) => Some(x),
+					Poll::Pending => None,
+				};
+			}
+			let ref_given = &mut *self_.ref_given;
+			let pending = &mut *self_.pending;
+			let mut progress = false;
+			{
+				let stream = stream::poll_fn(|_cx| match pending {
+					Some(x) if !*ref_given => {
+						*ref_given = true;
+						progress = true;
+						Poll::Ready(unsafe { transmute(x.as_ref()) })
+					}
+					_ => Poll::Pending,
+				})
+				.fuse();
+				pin_mut!(stream);
+				if let Poll::Ready(item) = self_.pipe_ref.as_mut().poll_next(cx, stream) {
+					return Poll::Ready(item.map(|item| Sum2::B(unsafe { transmute(item) })));
+				}
+			}
+			{
+				let stream = stream::poll_fn(|_cx| {
+					if !*ref_given {
+						return Poll::Pending;
+					}
+					match pending.take() {
+						Some(x) => {
+							*ref_given = false;
+							progress = true;
+							Poll::Ready(x)
+						}
+						None => Poll::Pending,
+					}
+				})
+				.fuse();
+				pin_mut!(stream);
+				if let Poll::Ready(item) = self_.pipe.as_mut().poll_next(cx, stream) {
+					return Poll::Ready(item.map(Sum2::A));
+				}
+			}
+			if !progress {
+				break Poll::Pending;
+			}
+		}
+	}
+}
diff --git a/amadeus-core/src/par_sink/group_by.rs b/amadeus-core/src/par_sink/group_by.rs
index b9ccd62b..999b0b29 100644
--- a/amadeus-core/src/par_sink/group_by.rs
+++ b/amadeus-core/src/par_sink/group_by.rs
@@ -2,89 +2,370 @@
 
 use derive_new::new;
 use educe::Educe;
-use either::Either;
-use replace_with::{replace_with_or_abort, replace_with_or_default};
+use futures::{future::join_all, pin_mut, ready, stream, Stream, StreamExt};
+use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, hash::Hash, marker::PhantomData, mem};
+use std::{
+	collections::HashMap, future::Future, hash::Hash, marker::PhantomData, mem, pin::Pin, task::{Context, Poll}
+};
 
 use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PipeTask, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+};
+use crate::{
+	pipe::{Pipe, Sink, StreamExt as _}, pool::ProcessSend
 };
 
 #[derive(new)]
 #[must_use]
-pub struct GroupBy<I, ID, F, B> {
-	i: I,
-	identity: ID,
-	op: F,
-	marker: PhantomData<fn() -> B>,
-}
-
-impl_par_dist! {
-	impl<I: ParallelPipe<Source, Item = (A, B)>, Source, A, B, ID, F, C> ParallelSink<Source>
-		for GroupBy<I, ID, F, C>
-	where
-		A: Eq + Hash + Send + 'static,
-		ID: FnMut() -> C + Clone + Send + 'static,
-		F: FnMut(C, Either<B, C>) -> C + Clone + Send + 'static,
-		C: Send + 'static,
-	{
-		folder_par_sink!(GroupByFolder<A, B, ID, F, C, StepA>, GroupByFolder<A, B, ID, F, C, StepB>, self, GroupByFolder::new(self.identity.clone(), self.op.clone()), GroupByFolder::new(self.identity, self.op));
+pub struct GroupBy<A, B> {
+	a: A,
+	b: B,
+}
+
+impl<A: ParallelPipe<Source, Item = (T, U)>, B: ParallelSink<U>, Source, T, U> ParallelSink<Source>
+	for GroupBy<A, B>
+where
+	T: Eq + Hash + Send + 'static,
+	<B::Pipe as ParallelPipe<U>>::Task: Clone + Send + 'static,
+	B::ReduceA: Clone + Send + 'static,
+	B::ReduceC: Clone,
+	B::Output: Send + 'static,
+{
+	type Output = HashMap<T, B::Output>;
+	type Pipe = A;
+	type ReduceA = GroupByReducerA<<B::Pipe as ParallelPipe<U>>::Task, B::ReduceA, T, U>;
+	type ReduceC = GroupByReducerB<
+		B::ReduceC,
+		T,
+		<B::ReduceA as ReducerSend<<B::Pipe as ParallelPipe<U>>::Item>>::Output,
+	>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
+		let (a, b, c) = self.b.reducers();
+		(
+			self.a,
+			GroupByReducerA::new(a.task(), b),
+			GroupByReducerB::new(c),
+		)
+	}
+}
+
+impl<A: DistributedPipe<Source, Item = (T, U)>, B: DistributedSink<U>, Source, T, U>
+	DistributedSink<Source> for GroupBy<A, B>
+where
+	T: Eq + Hash + ProcessSend + 'static,
+	<B::Pipe as DistributedPipe<U>>::Task: Clone + ProcessSend + 'static,
+	B::ReduceA: Clone + ProcessSend + 'static,
+	B::ReduceB: Clone,
+	B::ReduceC: Clone,
+	B::Output: ProcessSend + 'static,
+{
+	type Output = HashMap<T, B::Output>;
+	type Pipe = A;
+	type ReduceA = GroupByReducerA<<B::Pipe as DistributedPipe<U>>::Task, B::ReduceA, T, U>;
+	type ReduceB = GroupByReducerB<
+		B::ReduceB,
+		T,
+		<B::ReduceA as ReducerSend<<B::Pipe as DistributedPipe<U>>::Item>>::Output,
+	>;
+	type ReduceC = GroupByReducerB<
+		B::ReduceC,
+		T,
+		<B::ReduceB as ReducerProcessSend<
+			<B::ReduceA as Reducer<<B::Pipe as DistributedPipe<U>>::Item>>::Output,
+		>>::Output,
+	>;
+
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
+		let (a, b, c, d) = self.b.reducers();
+		(
+			self.a,
+			GroupByReducerA::new(a.task(), b),
+			GroupByReducerB::new(c),
+			GroupByReducerB::new(d),
+		)
 	}
 }
 
 #[derive(Educe, Serialize, Deserialize, new)]
-#[educe(Clone(bound = "ID: Clone, F: Clone"))]
+#[educe(Clone(bound = "P: Clone, R: Clone"))]
 #[serde(
-	bound(serialize = "ID: Serialize, F: Serialize"),
-	bound(deserialize = "ID: Deserialize<'de>, F: Deserialize<'de>")
+	bound(serialize = "P: Serialize, R: Serialize"),
+	bound(deserialize = "P: Deserialize<'de>, R: Deserialize<'de>")
 )]
-pub struct GroupByFolder<A, B, ID, F, C, Step> {
-	identity: ID,
-	op: F,
-	marker: PhantomData<fn() -> (A, B, C, Step)>,
-}
+pub struct GroupByReducerA<P, R, T, U>(P, R, PhantomData<fn() -> (R, T, U)>);
 
-pub struct StepA;
-pub struct StepB;
+impl<P, R, T, U> Reducer<(T, U)> for GroupByReducerA<P, R, T, U>
+where
+	P: PipeTask<U>,
+	R: Reducer<P::Item> + Clone,
+	T: Eq + Hash,
+{
+	type Output = HashMap<T, R::Output>;
+	type Async = GroupByReducerAAsync<P::Async, R, R::Async, T, U>;
 
-impl<A, B, ID, F, C> FolderSync<(A, B)> for GroupByFolder<A, B, ID, F, C, StepA>
+	fn into_async(self) -> Self::Async {
+		GroupByReducerAAsync::new(self.0.into_async(), self.1)
+	}
+}
+impl<P, R, T, U> ReducerProcessSend<(T, U)> for GroupByReducerA<P, R, T, U>
+where
+	P: PipeTask<U>,
+	R: Reducer<P::Item> + Clone,
+	T: Eq + Hash + ProcessSend + 'static,
+	R::Output: ProcessSend + 'static,
+{
+	type Output = HashMap<T, R::Output>;
+}
+impl<P, R, T, U> ReducerSend<(T, U)> for GroupByReducerA<P, R, T, U>
 where
-	A: Eq + Hash,
-	ID: FnMut() -> C,
-	F: FnMut(C, Either<B, C>) -> C,
+	P: PipeTask<U>,
+	R: Reducer<P::Item> + Clone,
+	T: Eq + Hash + Send + 'static,
+	R::Output: Send + 'static,
 {
-	type Output = HashMap<A, C>;
+	type Output = HashMap<T, R::Output>;
+}
+
+#[pin_project]
+#[derive(new)]
+pub struct GroupByReducerAAsync<P, R, RA, T, U> {
+	#[pin]
+	pipe: P,
+	factory: R,
+	#[new(default)]
+	pending: Option<Option<(T, Option<U>, Option<Pin<Box<RA>>>)>>,
+	#[new(default)]
+	map: HashMap<T, Pin<Box<RA>>>,
+	marker: PhantomData<fn() -> (R, U)>,
+}
 
-	fn zero(&mut self) -> Self::Output {
-		HashMap::new()
+impl<P, R, T, U> Sink<(T, U)> for GroupByReducerAAsync<P, R, R::Async, T, U>
+where
+	P: Pipe<U>,
+	R: Reducer<P::Item> + Clone,
+	T: Eq + Hash,
+{
+	#[inline(always)]
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = (T, U)>>,
+	) -> Poll<()> {
+		let mut self_ = self.project();
+		loop {
+			if !self_.pending.is_some() {
+				*self_.pending = Some(ready!(stream.as_mut().poll_next(cx)).map(|(t, u)| {
+					let r = if !self_.map.contains_key(&t) {
+						Some(Box::pin(self_.factory.clone().into_async()))
+					} else {
+						None
+					};
+					(t, Some(u), r)
+				}));
+			}
+			if let Some((t, u, r)) = self_.pending.as_mut().unwrap() {
+				let stream = stream::poll_fn(|_cx| {
+					if let Some(u) = u.take() {
+						Poll::Ready(Some(u))
+					} else {
+						Poll::Pending
+					}
+				})
+				.fuse()
+				.pipe(self_.pipe.as_mut());
+				pin_mut!(stream);
+				let map = &mut *self_.map;
+				let r_ = r.as_mut().unwrap_or_else(|| map.get_mut(&t).unwrap());
+				let _ = r_.as_mut().poll_pipe(cx, stream);
+				if u.is_some() {
+					return Poll::Pending;
+				}
+				let (t, _u, r) = self_.pending.take().unwrap().unwrap();
+				if let Some(r) = r {
+					let _ = self_.map.insert(t, r);
+				}
+			} else {
+				for r in self_.map.values_mut() {
+					let stream = stream::empty();
+					pin_mut!(stream);
+					ready!(r.as_mut().poll_pipe(cx, stream));
+				}
+				return Poll::Ready(());
+			}
+		}
 	}
-	fn push(&mut self, state: &mut Self::Output, (key, value): (A, B)) {
-		let state = state.entry(key).or_insert_with(&mut self.identity);
-		replace_with_or_abort(state, |state| (self.op)(state, Either::Left(value)))
+}
+impl<P, R, T, U> ReducerAsync<(T, U)> for GroupByReducerAAsync<P, R, R::Async, T, U>
+where
+	P: Pipe<U>,
+	R: Reducer<P::Item> + Clone,
+	T: Eq + Hash,
+{
+	type Output = HashMap<T, R::Output>;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move {
+			let self_ = self.project();
+			join_all(
+				mem::take(self_.map)
+					.into_iter()
+					.map(|(k, mut v)| async move { (k, v.as_mut().output().await) }),
+			)
+			.await
+			.into_iter()
+			.collect()
+		})
 	}
 }
-impl<A, B, ID, F, C> FolderSync<HashMap<A, C>> for GroupByFolder<A, B, ID, F, C, StepB>
+
+#[derive(Educe, Serialize, Deserialize, new)]
+#[educe(Clone(bound = "R: Clone"))]
+#[serde(
+	bound(serialize = "R: Serialize"),
+	bound(deserialize = "R: Deserialize<'de>")
+)]
+pub struct GroupByReducerB<R, T, U>(R, PhantomData<fn() -> (T, U)>);
+
+impl<R, T, U> Reducer<HashMap<T, U>> for GroupByReducerB<R, T, U>
 where
-	A: Eq + Hash,
-	ID: FnMut() -> C,
-	F: FnMut(C, Either<B, C>) -> C,
+	R: Reducer<U> + Clone,
+	T: Eq + Hash,
 {
-	type Output = HashMap<A, C>;
+	type Output = HashMap<T, R::Output>;
+	type Async = GroupByReducerBAsync<R, R::Async, T, U>;
 
-	fn zero(&mut self) -> Self::Output {
-		HashMap::new()
+	fn into_async(self) -> Self::Async {
+		GroupByReducerBAsync::new(self.0)
 	}
-	fn push(&mut self, state: &mut Self::Output, mut b: HashMap<A, C>) {
-		replace_with_or_default(state, |mut a| {
-			if a.len() < b.len() {
-				mem::swap(&mut a, &mut b);
+}
+impl<R, T, U> ReducerProcessSend<HashMap<T, U>> for GroupByReducerB<R, T, U>
+where
+	R: Reducer<U> + Clone,
+	T: Eq + Hash + ProcessSend + 'static,
+	R::Output: ProcessSend + 'static,
+{
+	type Output = HashMap<T, R::Output>;
+}
+impl<R, T, U> ReducerSend<HashMap<T, U>> for GroupByReducerB<R, T, U>
+where
+	R: Reducer<U> + Clone,
+	T: Eq + Hash + Send + 'static,
+	R::Output: Send + 'static,
+{
+	type Output = HashMap<T, R::Output>;
+}
+
+#[pin_project]
+#[derive(new)]
+pub struct GroupByReducerBAsync<R, RA, T, U> {
+	f: R,
+	#[new(default)]
+	pending: Option<Option<HashMap<T, (U, Option<Pin<Box<RA>>>)>>>,
+	#[new(default)]
+	map: HashMap<T, Pin<Box<RA>>>,
+	marker: PhantomData<fn() -> (T, U)>,
+}
+
+impl<R, T, U> Sink<HashMap<T, U>> for GroupByReducerBAsync<R, R::Async, T, U>
+where
+	R: Reducer<U> + Clone,
+	T: Eq + Hash,
+{
+	#[inline(always)]
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context,
+		mut stream: Pin<&mut impl Stream<Item = HashMap<T, U>>>,
+	) -> Poll<()> {
+		let self_ = self.project();
+		loop {
+			if self_.pending.is_none() {
+				*self_.pending = Some(ready!(stream.as_mut().poll_next(cx)).map(|item| {
+					item.into_iter()
+						.map(|(k, v)| {
+							let r = if !self_.map.contains_key(&k) {
+								Some(Box::pin(self_.f.clone().into_async()))
+							} else {
+								None
+							};
+							(k, (v, r))
+						})
+						.collect()
+				}));
 			}
-			for (key, value) in b {
-				let state = a.entry(key).or_insert_with(&mut self.identity);
-				replace_with_or_abort(state, |state| (self.op)(state, Either::Right(value)))
+			let pending = self_.pending.as_mut().unwrap();
+			if let Some(pending) = pending {
+				while let Some((k, (v, mut r))) = pop(pending) {
+					let mut v = Some(v);
+					let stream = stream::poll_fn(|_cx| {
+						if let Some(v) = v.take() {
+							Poll::Ready(Some(v))
+						} else {
+							Poll::Pending
+						}
+					});
+					pin_mut!(stream);
+					let map = &mut *self_.map;
+					let r_ = r.as_mut().unwrap_or_else(|| map.get_mut(&k).unwrap());
+					let _ = r_.as_mut().poll_pipe(cx, stream);
+					if let Some(v) = v {
+						let _ = pending.insert(k, (v, r));
+						return Poll::Pending;
+					}
+					if let Some(r) = r {
+						let _ = self_.map.insert(k, r);
+					}
+				}
+				*self_.pending = None;
+			} else {
+				for r in self_.map.values_mut() {
+					let stream = stream::empty();
+					pin_mut!(stream);
+					ready!(r.as_mut().poll_pipe(cx, stream));
+				}
+				return Poll::Ready(());
 			}
-			a
+		}
+	}
+}
+impl<R, T, U> ReducerAsync<HashMap<T, U>> for GroupByReducerBAsync<R, R::Async, T, U>
+where
+	R: Reducer<U> + Clone,
+	T: Eq + Hash,
+{
+	type Output = HashMap<T, R::Output>;
+
+	fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+		Box::pin(async move {
+			let self_ = self.project();
+			join_all(
+				mem::take(self_.map)
+					.into_iter()
+					.map(|(k, mut v)| async move { (k, v.as_mut().output().await) }),
+			)
+			.await
+			.into_iter()
+			.collect()
 		})
 	}
 }
+
+// https://github.com/rust-lang/rfcs/issues/1800#issuecomment-653757340
+#[allow(clippy::unnecessary_filter_map)]
+fn pop<K, V>(map: &mut HashMap<K, V>) -> Option<(K, V)>
+where
+	K: Eq + Hash,
+{
+	let mut first = None;
+	*map = mem::take(map)
+		.into_iter()
+		.filter_map(|el| {
+			if first.is_none() {
+				first = Some(el);
+				None
+			} else {
+				Some(el)
+			}
+		})
+		.collect();
+	first
+}
diff --git a/amadeus-core/src/par_sink/histogram.rs b/amadeus-core/src/par_sink/histogram.rs
index a2ae45bf..bbd3c416 100644
--- a/amadeus-core/src/par_sink/histogram.rs
+++ b/amadeus-core/src/par_sink/histogram.rs
@@ -7,9 +7,7 @@ use replace_with::replace_with_or_default;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, hash::Hash, marker::PhantomData};
 
-use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
-};
+use super::{folder_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink};
 
 #[derive(new)]
 #[must_use]
diff --git a/amadeus-core/src/par_sink/max.rs b/amadeus-core/src/par_sink/max.rs
index 3ffe300f..e5578202 100644
--- a/amadeus-core/src/par_sink/max.rs
+++ b/amadeus-core/src/par_sink/max.rs
@@ -3,9 +3,7 @@ use educe::Educe;
 use serde::{Deserialize, Serialize};
 use std::{cmp::Ordering, marker::PhantomData};
 
-use super::{
-	combiner_par_sink, CombinerSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
-};
+use super::{combiner_par_sink, CombinerSync, FolderSyncReducer, ParallelPipe, ParallelSink};
 
 #[derive(new)]
 #[must_use]
diff --git a/amadeus-core/src/par_sink/pipe.rs b/amadeus-core/src/par_sink/pipe.rs
index 6bb797d5..d0bf1a41 100644
--- a/amadeus-core/src/par_sink/pipe.rs
+++ b/amadeus-core/src/par_sink/pipe.rs
@@ -1,15 +1,11 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
-use std::{
-	marker::PhantomData, pin::Pin, task::{Context, Poll}
-};
 
-use super::{
-	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PipeTask, PipeTaskAsync
+use super::{DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PipeTask};
+use crate::{
+	par_stream::{ParallelStream, StreamTask}, pipe::{Pipe as _, PipePipe, StreamExt, StreamPipe}
 };
-use crate::sink::Sink;
 
 #[derive(new)]
 #[must_use]
@@ -19,6 +15,20 @@ pub struct Pipe<A, B> {
 }
 
 impl_par_dist! {
+	impl<A: ParallelStream, B: ParallelPipe<A::Item>> ParallelStream for Pipe<A, B> {
+		type Item = B::Item;
+		type Task = JoinTask<A::Task, B::Task>;
+
+		fn next_task(&mut self) -> Option<Self::Task> {
+			self.a.next_task().map(|a| {
+				let b = self.b.task();
+				JoinTask { a, b }
+			})
+		}
+		fn size_hint(&self) -> (usize, Option<usize>) {
+			self.a.size_hint()
+		}
+	}
 	impl<A: ParallelPipe<Source>, B: ParallelPipe<A::Item>, Source> ParallelPipe<Source> for Pipe<A, B> {
 		type Item = B::Item;
 		type Task = JoinTask<A::Task, B::Task>;
@@ -36,11 +46,10 @@ impl<A: ParallelPipe<Source>, B: ParallelSink<A::Item>, Source> ParallelSink<Sou
 {
 	type Output = B::Output;
 	type Pipe = Pipe<A, B::Pipe>;
-	type ReduceAFactory = B::ReduceAFactory;
 	type ReduceA = B::ReduceA;
 	type ReduceC = B::ReduceC;
 
-	fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
 		let (a, b, c) = self.b.reducers();
 		(Pipe::new(self.a, a), b, c)
 	}
@@ -50,20 +59,11 @@ impl<A: DistributedPipe<Source>, B: DistributedSink<A::Item>, Source> Distribute
 {
 	type Output = B::Output;
 	type Pipe = Pipe<A, B::Pipe>;
-	type ReduceAFactory = B::ReduceAFactory;
-	type ReduceBFactory = B::ReduceBFactory;
 	type ReduceA = B::ReduceA;
 	type ReduceB = B::ReduceB;
 	type ReduceC = B::ReduceC;
 
-	fn reducers(
-		self,
-	) -> (
-		Self::Pipe,
-		Self::ReduceAFactory,
-		Self::ReduceBFactory,
-		Self::ReduceC,
-	) {
+	fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		let (a, b, c, d) = self.b.reducers();
 		(Pipe::new(self.a, a), b, c, d)
 	}
@@ -78,46 +78,20 @@ pub struct JoinTask<A, B> {
 	b: B,
 }
 
-impl<A: PipeTask<Source>, B: PipeTask<A::Item>, Source> PipeTask<Source> for JoinTask<A, B> {
+impl<A: StreamTask, B: PipeTask<A::Item>> StreamTask for JoinTask<A, B> {
 	type Item = B::Item;
-	type Async = JoinTask<A::Async, B::Async>;
+	type Async = StreamPipe<A::Async, B::Async>;
+
 	fn into_async(self) -> Self::Async {
-		JoinTask {
-			a: self.a.into_async(),
-			b: self.b.into_async(),
-		}
+		self.a.into_async().pipe(self.b.into_async())
 	}
 }
 
-impl<A: PipeTaskAsync<Source>, B: PipeTaskAsync<A::Item>, Source> PipeTaskAsync<Source>
-	for JoinTask<A, B>
-{
+impl<A: PipeTask<Source>, B: PipeTask<A::Item>, Source> PipeTask<Source> for JoinTask<A, B> {
 	type Item = B::Item;
+	type Async = PipePipe<A::Async, B::Async>;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		#[pin_project]
-		struct Proxy<'a, I, B, Item>(#[pin] I, Pin<&'a mut B>, PhantomData<fn() -> Item>);
-		impl<'a, I, B, Item> Sink for Proxy<'a, I, B, Item>
-		where
-			I: Sink<Item = B::Item>,
-			B: PipeTaskAsync<Item>,
-		{
-			type Item = Item;
-
-			fn poll_forward(
-				self: Pin<&mut Self>, cx: &mut Context,
-				stream: Pin<&mut impl Stream<Item = Self::Item>>,
-			) -> Poll<()> {
-				let self_ = self.project();
-				self_.1.as_mut().poll_run(cx, stream, self_.0)
-			}
-		}
-		let self_ = self.project();
-		let sink = Proxy(sink, self_.b, PhantomData);
-		pin_mut!(sink);
-		self_.a.poll_run(cx, stream, sink)
+	fn into_async(self) -> Self::Async {
+		self.a.into_async().pipe(self.b.into_async())
 	}
 }
diff --git a/amadeus-core/src/par_sink/sample.rs b/amadeus-core/src/par_sink/sample.rs
index 71fce56d..1798f552 100644
--- a/amadeus-core/src/par_sink/sample.rs
+++ b/amadeus-core/src/par_sink/sample.rs
@@ -7,7 +7,7 @@ use std::hash::Hash;
 use streaming_algorithms::{HyperLogLogMagnitude, SampleUnstable as SASampleUnstable, Top};
 
 use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink, SumFolder, SumZeroFolder
+	folder_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink, SumFolder, SumZeroFolder
 };
 
 #[derive(new)]
diff --git a/amadeus-core/src/par_sink/sum.rs b/amadeus-core/src/par_sink/sum.rs
index b4a88ec3..aaaa7aab 100644
--- a/amadeus-core/src/par_sink/sum.rs
+++ b/amadeus-core/src/par_sink/sum.rs
@@ -4,9 +4,7 @@ use replace_with::replace_with_or_abort;
 use serde::{Deserialize, Serialize};
 use std::{iter, marker::PhantomData, mem};
 
-use super::{
-	folder_par_sink, FolderSync, FolderSyncReducer, FolderSyncReducerFactory, ParallelPipe, ParallelSink
-};
+use super::{folder_par_sink, FolderSync, FolderSyncReducer, ParallelPipe, ParallelSink};
 
 #[derive(new)]
 #[must_use]
diff --git a/amadeus-core/src/par_sink/tuple.rs b/amadeus-core/src/par_sink/tuple.rs
index 9dd538e1..2840188d 100644
--- a/amadeus-core/src/par_sink/tuple.rs
+++ b/amadeus-core/src/par_sink/tuple.rs
@@ -1,18 +1,23 @@
-#![allow(non_snake_case, clippy::type_complexity, irrefutable_let_patterns, clippy::new_without_default, unused_mut, unreachable_code)]
+#![allow(non_snake_case, clippy::type_complexity, irrefutable_let_patterns, clippy::new_without_default, unused_mut, unreachable_code, clippy::too_many_arguments)]
 
-use futures::{pin_mut, ready, stream, Stream, StreamExt};
+use derive_new::new;
+use futures::{
+	future::{
+		join as Join2, join3 as Join3, join4 as Join4, join5 as Join5, maybe_done, FusedFuture, MaybeDone
+	}, pin_mut, ready, stream, Stream, StreamExt
+};
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
-	pin::Pin, task::{Context, Poll}
+	future::Future, pin::Pin, task::{Context, Poll}
 };
-use sum::*;
+use sum::{Sum0, Sum1, Sum2, Sum3, Sum4, Sum5, Sum6, Sum7, Sum8};
 
 use super::{
-	DistributedPipe, DistributedSink, Factory, ParallelPipe, ParallelSink, PipeTask, PipeTaskAsync, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
+	DistributedPipe, DistributedSink, ParallelPipe, ParallelSink, PipeTask, Reducer, ReducerAsync, ReducerProcessSend, ReducerSend
 };
 use crate::{
-	pool::ProcessSend, sink::{Sink, SinkMap}
+	pipe::{Pipe, Sink}, pool::ProcessSend
 };
 
 fn substream<'a, 'b, S, F1, F2, O>(
@@ -39,7 +44,7 @@ where
 }
 
 macro_rules! impl_tuple {
-	($reduceafactory:ident $reducea:ident $reduceaasync:ident $reducebfactory:ident $reduceb:ident $reducebasync:ident $async:ident $enum:ident $($copy:ident)? : $($i:ident $r:ident $o:ident $c:ident $iterator:ident $reducera:ident $reducerb:ident $num:tt $t:ident $($copyb:ident)? , $comma:tt)*) => (
+	($reducea:ident $reduceaasync:ident $reduceb:ident $reducebasync:ident $async:ident $enum:ident $join:ident $($copy:ident)? : $($num:tt $t:ident $s:ident $i:ident $r:ident $o:ident $c:ident $iterator:ident $reducera:ident $reducerb:ident $($copyb:ident)? , $comma:tt)*) => (
 		impl<
 				Source,
 				$($r: ParallelSink<Source, Output = $o>,)*
@@ -49,15 +54,14 @@ macro_rules! impl_tuple {
 		{
 			type Output = ($($o,)*);
 			type Pipe = ($($r::Pipe,)*);
-			type ReduceAFactory = $reduceafactory<$($r::ReduceAFactory,)*>;
 			type ReduceA = $reducea<$($r::ReduceA,)*>;
 			type ReduceC = $reduceb<$($r::ReduceC,)*>;
 
-			fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceC) {
+			fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceC) {
 				$(let ($iterator, $reducera, $t) = self.$num.reducers();)*
 				(
 					($($iterator,)*),
-					$reduceafactory($($reducera,)*),
+					$reducea{$($t: $reducera,)*},
 					$reduceb{$($t,)*},
 				)
 			}
@@ -71,18 +75,16 @@ macro_rules! impl_tuple {
 		{
 			type Output = ($($o,)*);
 			type Pipe = ($($r::Pipe,)*);
-			type ReduceAFactory = $reduceafactory<$($r::ReduceAFactory,)*>;
-			type ReduceBFactory = $reducebfactory<$($r::ReduceBFactory,)*>;
 			type ReduceA = $reducea<$($r::ReduceA,)*>;
 			type ReduceB = $reduceb<$($r::ReduceB,)*>;
 			type ReduceC = $reduceb<$($r::ReduceC,)*>;
 
-			fn reducers(self) -> (Self::Pipe, Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+			fn reducers(self) -> (Self::Pipe, Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 				$(let ($iterator, $reducera, $reducerb, $t) = self.$num.reducers();)*
 				(
 					($($iterator,)*),
-					$reduceafactory($($reducera,)*),
-					$reducebfactory($($reducerb,)*),
+					$reducea{$($t: $reducera,)*},
+					$reduceb{$($t: $reducerb,)*},
 					$reduceb{$($t,)*},
 				)
 			}
@@ -134,85 +136,59 @@ macro_rules! impl_tuple {
 		}
 
 		#[allow(unused_variables)]
-		impl<Source, $($c: PipeTaskAsync<Source>,)*> PipeTaskAsync<Source> for $async<Source, $($c,)*>
+		impl<Source, $($c: Pipe<Source>,)*> Pipe<Source> for $async<Source, $($c,)*>
 		where
 			Source: $($copy)*,
 		{
 			type Item = $enum<$($c::Item,)*>;
 
 			#[allow(non_snake_case)]
-			fn poll_run(
+			fn poll_next(
 				self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = Source>>,
-				mut sink: Pin<&mut impl Sink<Item = Self::Item>>,
-			) -> Poll<()> {
+			) -> Poll<Option<Self::Item>> {
 				let mut self_ = self.project();
 				// buffer, copy to each
-				let mut ready = ($(false $comma)*);
 				loop {
-					let mut progress = false;
 					if self_.pending.is_none() {
 						*self_.pending = match stream.as_mut().poll_next(cx) { Poll::Ready(x) => Some(x), Poll::Pending => None};
 					}
-					$(
-						if !ready.$num {
-							let sink_ = SinkMap::new(sink.as_mut(), $enum::$t);
-							pin_mut!(sink_);
-							let pending = &mut self_.pending;
-							let given = &mut self_.given.$num;
-							let stream_ = stream::poll_fn(|cx| {
-								if !*given && pending.is_some() {
-									*given = true;
-									progress = true;
-									$(
-										return Poll::Ready(*pending.as_ref().unwrap());
-										let $copyb = ();
-									)?
-									Poll::Ready(pending.take().unwrap().take())
-								} else {
-									Poll::Pending
-								}
-							}).fuse();
-							pin_mut!(stream_);
-							ready.$num = self_.$t.as_mut().poll_run(cx, stream_, sink_).is_ready();
-							if ready.$num {
-								self_.given.$num = true;
+					$({
+						let pending = &mut *self_.pending;
+						let given = &mut self_.given.$num;
+						let stream_ = stream::poll_fn(|cx| {
+							if !*given && pending.is_some() {
+								*given = true;
+								$(
+									return Poll::Ready(*pending.as_ref().unwrap());
+									let $copyb = ();
+								)?
+								Poll::Ready(pending.take().unwrap().take())
+							} else {
+								Poll::Pending
 							}
+						}).fuse();
+						pin_mut!(stream_);
+						if let Poll::Ready(item) = self_.$t.as_mut().poll_next(cx, stream_) {
+							return Poll::Ready(item.map($enum::$t));
 						}
-					)*
-					if $(ready.$num &&)* true {
-						break Poll::Ready(());
-					}
-					if !progress {
-						break Poll::Pending;
-					}
+					})*
 					if $(self_.given.$num &&)* true {
 						$(self_.given.$num = false;)*
 						*self_.pending = None;
+					} else {
+						break Poll::Pending;
 					}
 				}
 			}
 		}
 
-		#[derive(Clone, Serialize, Deserialize)]
-		pub struct $reduceafactory<$($r,)*>($(pub(crate) $r,)*);
-		impl<$($r:Factory,)*> Factory for $reduceafactory<$($r,)*> {
-			type Item = $reducea<$($r::Item,)*>;
-
-			fn make(&self) -> Self::Item {
-				$reducea{
-					$($t: self.$num.make(),)*
-				}
-			}
-		}
-
-		#[derive(Serialize, Deserialize)]
+		#[derive(Clone, Serialize, Deserialize, new)]
 		pub struct $reducea<$($t,)*> {
 			$($t: $t,)*
 		}
-		impl<$($t: Reducer,)*> Reducer for $reducea<$($t,)*> {
-			type Item = $enum<$($t::Item,)*>;
+		impl<$($t: Reducer<$s>,)* $($s,)*> Reducer<$enum<$($s,)*>> for $reducea<$($t,)*> {
 			type Output = ($($t::Output,)*);
-			type Async = $reduceaasync<$($t::Async,)*>;
+			type Async = $reduceaasync<$($t::Async,)* $($s,)*>;
 
 			fn into_async(self) -> Self::Async {
 				$reduceaasync{
@@ -222,18 +198,21 @@ macro_rules! impl_tuple {
 				}
 			}
 		}
+		impl<$($t: Reducer<$s>,)* $($s,)*> ReducerProcessSend<$enum<$($s,)*>> for $reducea<$($t,)*> where $($t::Output: ProcessSend + 'static,)* {
+			type Output = ($($t::Output,)*);
+		}
+		impl<$($t: Reducer<$s>,)* $($s,)*> ReducerSend<$enum<$($s,)*>> for $reducea<$($t,)*> where $($t::Output: Send + 'static,)* {
+			type Output = ($($t::Output,)*);
+		}
 		#[pin_project]
-		pub struct $reduceaasync<$($t,)*> where $($t: ReducerAsync,)* {
+		pub struct $reduceaasync<$($t,)* $($s,)*> where $($t: ReducerAsync<$s>,)* {
 			$(#[pin] $t: $t,)*
-			peeked: Option<$enum<$($t::Item,)*>>,
+			peeked: Option<$enum<$($s,)*>>,
 			output: ($(Option<$t::Output>,)*),
 		}
 		#[allow(unused_variables)]
-		impl<$($t: ReducerAsync,)*> ReducerAsync for $reduceaasync<$($t,)*> {
-			type Item = $enum<$($t::Item,)*>;
-			type Output = ($($t::Output,)*);
-
-			fn poll_forward(self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = Self::Item>>) -> Poll<()> {
+		impl<$($t: ReducerAsync<$s>,)* $($s,)*> Sink<$enum<$($s,)*>> for $reduceaasync<$($t,)* $($s,)*> {
+			fn poll_pipe(self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = $enum<$($s,)*>>>) -> Poll<()> {
 				let mut self_ = self.project();
 				let mut ready = ($(false $comma)*);
 				loop {
@@ -243,7 +222,7 @@ macro_rules! impl_tuple {
 						pin_mut!(stream);
 						let stream_ = substream(stream, |item| if let $enum::$t(_) = item { true } else { false }, |item| { progress = true; if let $enum::$t(item) = item { item } else { unreachable!() } });
 						pin_mut!(stream_);
-						ready.$num = self_.$t.as_mut().poll_forward(cx, stream_).is_ready();
+						ready.$num = self_.$t.as_mut().poll_pipe(cx, stream_).is_ready();
 					})*
 					if $(ready.$num &&)* true {
 						break Poll::Ready(())
@@ -253,59 +232,26 @@ macro_rules! impl_tuple {
 					}
 				}
 			}
-			fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-				let mut self_ = self.project();
-				let mut pending = false;
-				$(
-					if self_.output.$num.is_none() {
-						if let Poll::Ready(output) = self_.$t.poll_output(cx) {
-							self_.output.$num = Some(output);
-						} else {
-							pending = true;
-						}
-					}
-				)*
-				if !pending {
-					Poll::Ready(($(self_.output.$num.take().unwrap(),)*))
-				} else {
-					Poll::Pending
-				}
-			}
-		}
-		impl<$($t: Reducer,)*> ReducerProcessSend for $reducea<$($t,)*> where $($t::Output: ProcessSend + 'static,)* {
-			type Output = ($($t::Output,)*);
 		}
-		impl<$($t: Reducer,)*> ReducerSend for $reducea<$($t,)*> where $($t::Output: Send + 'static,)* {
+		#[allow(unused_variables)]
+		impl<$($t: ReducerAsync<$s>,)* $($s,)*> ReducerAsync<$enum<$($s,)*>> for $reduceaasync<$($t,)* $($s,)*> {
 			type Output = ($($t::Output,)*);
-		}
-
-		pub struct $reducebfactory<$($r,)*>($(pub(crate) $r,)*);
-		impl<$($r:Factory,)*> Factory for $reducebfactory<$($r,)*> {
-			type Item = $reduceb<$($r::Item,)*>;
 
-			fn make(&self) -> Self::Item {
-				$reduceb{
-					$($t: self.$num.make(),)*
-				}
+			fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+				Box::pin(async move {
+					let self_ = self.project();
+					$join($(self_.$t.output(),)*).await
+				})
 			}
 		}
 
-		#[derive(Serialize, Deserialize)]
+		#[derive(Clone, Serialize, Deserialize, new)]
 		pub struct $reduceb<$($t,)*> {
 			$($t: $t,)*
 		}
-		impl<$($t,)*> $reduceb<$($t,)*> {
-			#[allow(clippy::too_many_arguments)]
-			pub fn new($($t: $t,)*) -> Self {
-				Self {
-					$($t,)*
-				}
-			}
-		}
-		impl<$($t: Reducer,)*> Reducer for $reduceb<$($t,)*> {
-			type Item = ($($t::Item,)*);
+		impl<$($t: Reducer<$s>,)* $($s,)*> Reducer<($($s,)*)> for $reduceb<$($t,)*> {
 			type Output = ($($t::Output,)*);
-			type Async = $reducebasync<$($t::Async,)*>;
+			type Async = $reducebasync<$($t::Async,)* $($s,)*>;
 
 			fn into_async(self) -> Self::Async {
 				$reducebasync{
@@ -315,24 +261,21 @@ macro_rules! impl_tuple {
 				}
 			}
 		}
-		impl<$($t: ReducerProcessSend,)*> ReducerProcessSend for $reduceb<$($t,)*> {
-			type Output = ($(<$t as ReducerProcessSend>::Output,)*);
+		impl<$($t: ReducerProcessSend<$s>,)* $($s,)*> ReducerProcessSend<($($s,)*)> for $reduceb<$($t,)*> {
+			type Output = ($(<$t as ReducerProcessSend<$s>>::Output,)*);
 		}
-		impl<$($t: ReducerSend,)*> ReducerSend for $reduceb<$($t,)*> {
-			type Output = ($(<$t as ReducerSend>::Output,)*);
+		impl<$($t: ReducerSend<$s>,)* $($s,)*> ReducerSend<($($s,)*)> for $reduceb<$($t,)*> {
+			type Output = ($(<$t as ReducerSend<$s>>::Output,)*);
 		}
 		#[pin_project]
-		pub struct $reducebasync<$($t,)*> where $($t: ReducerAsync,)* {
+		pub struct $reducebasync<$($t,)* $($s,)*> where $($t: ReducerAsync<$s>,)* {
 			$(#[pin] $t: $t,)*
-			peeked: Option<($(Option<$t::Item>,)*)>,
+			peeked: Option<($(Option<$s>,)*)>,
 			output: ($(Option<$t::Output>,)*),
 		}
 		#[allow(unused_variables)]
-		impl<$($t: ReducerAsync,)*> ReducerAsync for $reducebasync<$($t,)*> {
-			type Item = ($($t::Item,)*);
-			type Output = ($($t::Output,)*);
-
-			fn poll_forward(self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>) -> Poll<()> {
+		impl<$($t: ReducerAsync<$s>,)* $($s,)*> Sink<($($s,)*)> for $reducebasync<$($t,)* $($s,)*> {
+			fn poll_pipe(self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = ($($s,)*)>>) -> Poll<()> {
 				let mut self_ = self.project();
 				let mut ready = ($(false $comma)*);
 				let stream = stream.map(|item| ($(Some(item.$num),)*));
@@ -354,7 +297,7 @@ macro_rules! impl_tuple {
 							None => Poll::Ready(None),
 						}).fuse();
 						pin_mut!(stream);
-						ready.$num = self_.$t.as_mut().poll_forward(cx, stream).is_ready();
+						ready.$num = self_.$t.as_mut().poll_pipe(cx, stream).is_ready();
 					})*
 					if let Some(peeked) = self_.peeked {
 						if $(peeked.$num.is_none() &&)* true {
@@ -370,36 +313,29 @@ macro_rules! impl_tuple {
 					}
 				}
 			}
-			fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-				let mut self_ = self.project();
-				let mut pending = false;
-				$(
-					if self_.output.$num.is_none() {
-						if let Poll::Ready(output) = self_.$t.poll_output(cx) {
-							self_.output.$num = Some(output);
-						} else {
-							pending = true;
-						}
-					}
-				)*
-				if !pending {
-					Poll::Ready(($(self_.output.$num.take().unwrap(),)*))
-				} else {
-					Poll::Pending
-				}
+		}
+		#[allow(unused_variables)]
+		impl<$($t: ReducerAsync<$s>,)* $($s,)*> ReducerAsync<($($s,)*)> for $reducebasync<$($t,)* $($s,)*> {
+			type Output = ($($t::Output,)*);
+
+			fn output<'a>(self: Pin<&'a mut Self>) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> {
+				Box::pin(async move {
+					let self_ = self.project();
+					$join($(self_.$t.output(),)*).await
+				})
 			}
 		}
 	);
 }
-impl_tuple!(ReduceA0Factory ReduceA0 ReduceA0Async ReduceC0Factory ReduceC0 ReduceC0Async AsyncTuple0 Sum0:);
-impl_tuple!(ReduceA1Factory ReduceA1 ReduceA1Async ReduceC1Factory ReduceC1 ReduceC1Async AsyncTuple1 Sum1: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A,,);
-impl_tuple!(ReduceA2Factory ReduceA2 ReduceA2Async ReduceC2Factory ReduceC2 ReduceC2Async AsyncTuple2 Sum2 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,,);
-impl_tuple!(ReduceA3Factory ReduceA3 ReduceA3Async ReduceC3Factory ReduceC3 ReduceC3Async AsyncTuple3 Sum3 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,,);
-impl_tuple!(ReduceA4Factory ReduceA4 ReduceA4Async ReduceC4Factory ReduceC4 ReduceC4Async AsyncTuple4 Sum4 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,, I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 3 D Copy,,);
-impl_tuple!(ReduceA5Factory ReduceA5 ReduceA5Async ReduceC5Factory ReduceC5 ReduceC5Async AsyncTuple5 Sum5 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,, I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 3 D Copy,, I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 4 E Copy,,);
-impl_tuple!(ReduceA6Factory ReduceA6 ReduceA6Async ReduceC6Factory ReduceC6 ReduceC6Async AsyncTuple6 Sum6 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,, I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 3 D Copy,, I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 4 E Copy,, I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 5 F Copy,,);
-impl_tuple!(ReduceA7Factory ReduceA7 ReduceA7Async ReduceC7Factory ReduceC7 ReduceC7Async AsyncTuple7 Sum7 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,, I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 3 D Copy,, I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 4 E Copy,, I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 5 F Copy,, I6 R6 O6 C6 iterator_6 reducer_a_6 reducer_b_6 6 G Copy,,);
-impl_tuple!(ReduceA8Factory ReduceA8 ReduceA8Async ReduceC8Factory ReduceC8 ReduceC8Async AsyncTuple8 Sum8 Copy: I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 0 A Copy,, I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 1 B Copy,, I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 2 C Copy,, I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 3 D Copy,, I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 4 E Copy,, I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 5 F Copy,, I6 R6 O6 C6 iterator_6 reducer_a_6 reducer_b_6 6 G Copy,, I7 R7 O7 C7 iterator_7 reducer_a_7 reducer_b_7 7 H Copy,,);
+impl_tuple!(ReduceA0 ReduceA0Async ReduceC0 ReduceC0Async AsyncTuple0 Sum0 Join0:);
+impl_tuple!(ReduceA1 ReduceA1Async ReduceC1 ReduceC1Async AsyncTuple1 Sum1 Join1: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0,,);
+impl_tuple!(ReduceA2 ReduceA2Async ReduceC2 ReduceC2Async AsyncTuple2 Sum2 Join2 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,,);
+impl_tuple!(ReduceA3 ReduceA3Async ReduceC3 ReduceC3Async AsyncTuple3 Sum3 Join3 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,,);
+impl_tuple!(ReduceA4 ReduceA4Async ReduceC4 ReduceC4Async AsyncTuple4 Sum4 Join4 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,, 3 D S3 I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 Copy,,);
+impl_tuple!(ReduceA5 ReduceA5Async ReduceC5 ReduceC5Async AsyncTuple5 Sum5 Join5 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,, 3 D S3 I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 Copy,, 4 E S4 I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 Copy,,);
+impl_tuple!(ReduceA6 ReduceA6Async ReduceC6 ReduceC6Async AsyncTuple6 Sum6 Join6 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,, 3 D S3 I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 Copy,, 4 E S4 I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 Copy,, 5 F S5 I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 Copy,,);
+impl_tuple!(ReduceA7 ReduceA7Async ReduceC7 ReduceC7Async AsyncTuple7 Sum7 Join7 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,, 3 D S3 I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 Copy,, 4 E S4 I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 Copy,, 5 F S5 I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 Copy,, 6 G S6 I6 R6 O6 C6 iterator_6 reducer_a_6 reducer_b_6 Copy,,);
+impl_tuple!(ReduceA8 ReduceA8Async ReduceC8 ReduceC8Async AsyncTuple8 Sum8 Join8 Copy: 0 A S0 I0 R0 O0 C0 iterator_0 reducer_a_0 reducer_b_0 Copy,, 1 B S1 I1 R1 O1 C1 iterator_1 reducer_a_1 reducer_b_1 Copy,, 2 C S2 I2 R2 O2 C2 iterator_2 reducer_a_2 reducer_b_2 Copy,, 3 D S3 I3 R3 O3 C3 iterator_3 reducer_a_3 reducer_b_3 Copy,, 4 E S4 I4 R4 O4 C4 iterator_4 reducer_a_4 reducer_b_4 Copy,, 5 F S5 I5 R5 O5 C5 iterator_5 reducer_a_5 reducer_b_5 Copy,, 6 G S6 I6 R6 O6 C6 iterator_6 reducer_a_6 reducer_b_6 Copy,, 7 H S7 I7 R7 O7 C7 iterator_7 reducer_a_7 reducer_b_7 Copy,,);
 
 #[pin_project(project = PeekableProj)]
 #[derive(Debug)]
@@ -448,3 +384,60 @@ impl<'a, S: Stream> Stream for Peekable<'a, S> {
 		(lower, upper)
 	}
 }
+
+// from https://github.com/rust-lang/futures-rs/blob/19831dbecd13961fbd4243c1114663e24299c33d/futures-util/src/future/join.rs
+macro_rules! generate {
+	($(
+		($Join:ident, <$($Fut:ident),*>),
+	)*) => ($(
+		#[pin_project]
+		struct $Join<$($Fut: Future),*> {
+			$(#[pin] $Fut: MaybeDone<$Fut>,)*
+			dummy: (),
+		}
+
+		fn $Join<$($Fut: Future),*>($($Fut: $Fut),*) -> $Join<$($Fut),*> {
+			$Join {
+				$($Fut: maybe_done($Fut),)*
+				dummy: (),
+			}
+		}
+
+		#[allow(unused_variables)]
+		impl<$($Fut: Future),*> Future for $Join<$($Fut),*> {
+			type Output = ($($Fut::Output,)*);
+
+			fn poll(
+				self: Pin<&mut Self>, cx: &mut Context<'_>
+			) -> Poll<Self::Output> {
+				let mut all_done = true;
+				let mut futures = self.project();
+				$(
+					all_done &= futures.$Fut.as_mut().poll(cx).is_ready();
+				)*
+
+				if all_done {
+					Poll::Ready(($(futures.$Fut.take_output().unwrap(),)*))
+				} else {
+					Poll::Pending
+				}
+			}
+		}
+
+		impl<$($Fut: FusedFuture),*> FusedFuture for $Join<$($Fut),*> {
+			fn is_terminated(&self) -> bool {
+				$(
+					self.$Fut.is_terminated() &&
+				)* true
+			}
+		}
+	)*)
+}
+
+generate! {
+	(Join0, <>),
+	(Join1, <Fut1>),
+	(Join6, <Fut1, Fut2, Fut3, Fut4, Fut5, Fut6>),
+	(Join7, <Fut1, Fut2, Fut3, Fut4, Fut5, Fut6, Fut7>),
+	(Join8, <Fut1, Fut2, Fut3, Fut4, Fut5, Fut6, Fut7, Fut8>),
+}
diff --git a/amadeus-core/src/par_stream.rs b/amadeus-core/src/par_stream.rs
index eebe383a..46d7ca99 100644
--- a/amadeus-core/src/par_stream.rs
+++ b/amadeus-core/src/par_stream.rs
@@ -1,6 +1,8 @@
 // TODO: P: Pool -> impl Pool: async_trait triggers https://github.com/rust-lang/rust/issues/71869
 // TODO: how to dedup??
 
+#![allow(clippy::too_many_lines)]
+
 mod chain;
 mod cloned;
 mod filter;
@@ -11,19 +13,14 @@ mod map;
 mod sum_type;
 mod update;
 
-use ::sum::*;
 use async_trait::async_trait;
 use either::Either;
-use futures::{pin_mut, ready, stream, stream::StreamExt, Stream};
-use pin_project::pin_project;
-use serde::{Deserialize, Serialize};
+use futures::{pin_mut, stream::StreamExt as _, Stream};
 use serde_closure::*;
-use std::{
-	cmp::Ordering, collections::HashMap, future::Future, hash::Hash, iter, marker::PhantomData, ops::{DerefMut, FnMut}, pin::Pin, task::{Context, Poll}, vec
-};
+use std::{cmp::Ordering, collections::HashMap, hash::Hash, iter, ops::FnMut, vec};
 
 use crate::{
-	into_par_stream::IntoDistributedStream, pool::{ProcessPool, ProcessSend, ThreadPool}, sink::{Sink, SinkMap}, util::type_coerce
+	into_par_stream::IntoDistributedStream, pipe::StreamExt, pool::{ProcessPool, ProcessSend, ThreadPool}
 };
 
 pub use self::{
@@ -35,44 +32,10 @@ use super::{par_pipe::*, par_sink::*};
 #[must_use]
 pub trait StreamTask {
 	type Item;
-	type Async: StreamTaskAsync<Item = Self::Item>;
+	type Async: Stream<Item = Self::Item>;
 
 	fn into_async(self) -> Self::Async;
 }
-#[must_use]
-pub trait StreamTaskAsync {
-	type Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()>;
-}
-
-impl<P> StreamTaskAsync for Pin<P>
-where
-	P: DerefMut + Unpin,
-	P::Target: StreamTaskAsync,
-{
-	type Item = <P::Target as StreamTaskAsync>::Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		self.get_mut().as_mut().poll_run(cx, sink)
-	}
-}
-impl<T: ?Sized> StreamTaskAsync for &mut T
-where
-	T: StreamTaskAsync + Unpin,
-{
-	type Item = T::Item;
-
-	fn poll_run(
-		mut self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		Pin::new(&mut **self).poll_run(cx, sink)
-	}
-}
 
 #[async_trait(?Send)]
 #[must_use]
@@ -115,10 +78,9 @@ pub trait DistributedStream {
 		assert_distributed_stream(FlatMap::new(self, f))
 	}
 
-	fn filter<F, Fut>(self, f: F) -> Filter<Self, F>
+	fn filter<F>(self, f: F) -> Filter<Self, F>
 	where
-		F: FnMut(&Self::Item) -> Fut + Clone + ProcessSend + 'static,
-		Fut: Future<Output = bool>,
+		F: FnMut(&Self::Item) -> bool + Clone + ProcessSend + 'static,
 		Self: Sized,
 	{
 		assert_distributed_stream(Filter::new(self, f))
@@ -132,16 +94,20 @@ pub trait DistributedStream {
 		assert_distributed_stream(Chain::new(self, chain.into_dist_stream()))
 	}
 
-	async fn reduce<P, B, R1F, R2F, R1, R2, R3>(
-		mut self, pool: &P, reduce_a_factory: R1F, reduce_b_factory: R2F, reduce_c: R3,
+	async fn reduce<P, B, R1, R2, R3>(
+		mut self, pool: &P, reduce_a_factory: R1, reduce_b_factory: R2, reduce_c: R3,
 	) -> B
 	where
 		P: ProcessPool,
-		R1F: Factory<Item = R1> + Clone + ProcessSend + 'static,
-		R2F: Factory<Item = R2>,
-		R1: ReducerSend<Item = Self::Item> + Send + 'static,
-		R2: ReducerProcessSend<Item = <R1 as Reducer>::Output> + ProcessSend + 'static,
-		R3: Reducer<Item = <R2 as ReducerProcessSend>::Output, Output = B>,
+		R1: ReducerSend<Self::Item> + Clone + ProcessSend + 'static,
+		R2: ReducerProcessSend<<R1 as ReducerSend<Self::Item>>::Output>
+			+ Clone
+			+ ProcessSend
+			+ 'static,
+		R3: Reducer<
+			<R2 as ReducerProcessSend<<R1 as ReducerSend<Self::Item>>::Output>>::Output,
+			Output = B,
+		>,
 		Self::Task: 'static,
 		Self: Sized,
 	{
@@ -191,26 +157,9 @@ pub trait DistributedStream {
 			.into_iter()
 			.filter(|tasks| !tasks.is_empty())
 			.map(|tasks| {
-				let reduce_b = reduce_b_factory.make();
+				let reduce_b = reduce_b_factory.clone();
 				let reduce_a_factory = reduce_a_factory.clone();
 				pool.spawn(FnOnce!(move |pool: &P::ThreadPool| {
-					#[pin_project]
-					struct Connect<B>(#[pin] B);
-					impl<B> Sink for Connect<B>
-					where
-						B: ReducerAsync,
-					{
-						type Item = B::Item;
-
-						fn poll_forward(
-							self: Pin<&mut Self>, cx: &mut Context,
-							stream: Pin<&mut impl Stream<Item = B::Item>>,
-						) -> Poll<()> {
-							let self_ = self.project();
-							self_.0.poll_forward(cx, stream)
-						}
-					}
-
 					let mut process_tasks = tasks.into_iter();
 
 					let mut tasks = (0..pool.threads()).map(|_| vec![]).collect::<Vec<_>>();
@@ -257,24 +206,17 @@ pub trait DistributedStream {
 						.into_iter()
 						.filter(|tasks| !tasks.is_empty())
 						.map(|tasks| {
-							let reduce_a = reduce_a_factory.make();
+							let reduce_a = reduce_a_factory.clone();
 							pool.spawn(move || {
-								let sink = Connect(reduce_a.into_async());
 								async move {
+									let sink = reduce_a.into_async();
 									pin_mut!(sink);
 									// TODO: short circuit
 									for task in tasks {
 										let task = task.into_async();
-										pin_mut!(task);
-										futures::future::poll_fn(|cx| {
-											task.as_mut().poll_run(cx, sink.as_mut())
-										})
-										.await
+										task.sink(sink.as_mut()).await;
 									}
-									futures::future::poll_fn(|cx| {
-										sink.as_mut().project().0.as_mut().poll_output(cx)
-									})
-									.await
+									sink.output().await
 								}
 							})
 						})
@@ -287,13 +229,9 @@ pub trait DistributedStream {
 					});
 					let reduce_b = reduce_b.into_async();
 					async move {
-						pin_mut!(stream);
 						pin_mut!(reduce_b);
-						futures::future::poll_fn(|cx| {
-							ready!(reduce_b.as_mut().poll_forward(cx, stream.as_mut()));
-							reduce_b.as_mut().poll_output(cx)
-						})
-						.await
+						stream.sink(reduce_b.as_mut()).await;
+						reduce_b.output().await
 					}
 				}))
 			})
@@ -301,14 +239,10 @@ pub trait DistributedStream {
 		let stream = handles.map(|item| {
 			item.unwrap_or_else(|err| panic!("Amadeus: task '<unnamed>' panicked at '{}'", err))
 		});
-		pin_mut!(stream);
 		let reduce_c = reduce_c.into_async();
 		pin_mut!(reduce_c);
-		futures::future::poll_fn(|cx| {
-			ready!(reduce_c.as_mut().poll_forward(cx, stream.as_mut()));
-			reduce_c.as_mut().poll_output(cx)
-		})
-		.await
+		stream.sink(reduce_c.as_mut()).await;
+		reduce_c.output().await
 	}
 
 	async fn pipe<P, DistSink, A>(self, pool: &P, sink: DistSink) -> A
@@ -316,80 +250,13 @@ pub trait DistributedStream {
 		P: ProcessPool,
 		DistSink: DistributedSink<Self::Item, Output = A>,
 		<DistSink::Pipe as DistributedPipe<Self::Item>>::Task: 'static,
-		DistSink::ReduceAFactory: 'static,
 		DistSink::ReduceA: 'static,
 		DistSink::ReduceB: 'static,
 		Self::Task: 'static,
 		Self: Sized,
 	{
-		struct Connect<A, B>(A, B);
-		impl<A: DistributedStream, B: DistributedPipe<A::Item>> DistributedStream for Connect<A, B> {
-			type Item = B::Item;
-			type Task = ConnectTask<A::Task, B::Task>;
-			fn size_hint(&self) -> (usize, Option<usize>) {
-				self.0.size_hint()
-			}
-			fn next_task(&mut self) -> Option<Self::Task> {
-				self.0
-					.next_task()
-					.map(|task| ConnectTask(task, self.1.task()))
-			}
-		}
-		#[derive(Serialize, Deserialize)]
-		#[serde(
-			bound(serialize = "A: Serialize, B: Serialize"),
-			bound(deserialize = "A: Deserialize<'de>, B: Deserialize<'de>")
-		)]
-		struct ConnectTask<A, B>(A, B);
-		impl<A, B> StreamTask for ConnectTask<A, B>
-		where
-			A: StreamTask,
-			B: PipeTask<A::Item>,
-		{
-			type Item = B::Item;
-			type Async = ConnectStreamTaskAsync<A::Async, B::Async>;
-			fn into_async(self) -> Self::Async {
-				ConnectStreamTaskAsync(self.0.into_async(), self.1.into_async())
-			}
-		}
-		#[pin_project]
-		struct ConnectStreamTaskAsync<A, B>(#[pin] A, #[pin] B);
-		impl<A, B> StreamTaskAsync for ConnectStreamTaskAsync<A, B>
-		where
-			A: StreamTaskAsync,
-			B: PipeTaskAsync<A::Item>,
-		{
-			type Item = B::Item;
-			fn poll_run(
-				self: Pin<&mut Self>, cx: &mut Context,
-				sink: Pin<&mut impl Sink<Item = Self::Item>>,
-			) -> Poll<()> {
-				#[pin_project]
-				struct Proxy<'a, I, B, Item>(#[pin] I, Pin<&'a mut B>, PhantomData<fn() -> Item>);
-				impl<'a, I, B, Item> Sink for Proxy<'a, I, B, Item>
-				where
-					I: Sink<Item = B::Item>,
-					B: PipeTaskAsync<Item>,
-				{
-					type Item = Item;
-
-					fn poll_forward(
-						self: Pin<&mut Self>, cx: &mut Context,
-						stream: Pin<&mut impl Stream<Item = Self::Item>>,
-					) -> Poll<()> {
-						let self_ = self.project();
-						self_.1.as_mut().poll_run(cx, stream, self_.0)
-					}
-				}
-				let self_ = self.project();
-				let sink = Proxy(sink, self_.1, PhantomData);
-				pin_mut!(sink);
-				self_.0.poll_run(cx, sink)
-			}
-		}
-
 		let (iterator, reducer_a, reducer_b, reducer_c) = sink.reducers();
-		Connect(self, iterator)
+		Pipe::new(self, iterator)
 			.reduce(pool, reducer_a, reducer_b, reducer_c)
 			.await
 	}
@@ -403,10 +270,8 @@ pub trait DistributedStream {
 		DistSinkA: DistributedSink<Self::Item, Output = A>,
 		DistSinkB: for<'a> DistributedSink<&'a Self::Item, Output = B> + 'static,
 		<DistSinkA::Pipe as DistributedPipe<Self::Item>>::Task: 'static,
-		DistSinkA::ReduceAFactory: 'static,
 		DistSinkA::ReduceA: 'static,
 		DistSinkA::ReduceB: 'static,
-		<DistSinkB as DistributedSink<&'static Self::Item>>::ReduceAFactory: 'static,
 		<DistSinkB as DistributedSink<&'static Self::Item>>::ReduceA: 'static,
 		<DistSinkB as DistributedSink<&'static Self::Item>>::ReduceB: 'static,
 		<<DistSinkB as DistributedSink<&'static Self::Item>>::Pipe as DistributedPipe<
@@ -416,164 +281,13 @@ pub trait DistributedStream {
 		Self::Task: 'static,
 		Self: Sized,
 	{
-		struct Connect<A, B, C, RefAItem>(A, B, C, PhantomData<fn() -> RefAItem>);
-		impl<A, B, C, RefAItem> DistributedStream for Connect<A, B, C, RefAItem>
-		where
-			A: DistributedStream,
-			B: DistributedPipe<A::Item>,
-			C: DistributedPipe<RefAItem>,
-			RefAItem: 'static,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			type Task = ConnectTask<A::Task, B::Task, C::Task, RefAItem>;
-			fn size_hint(&self) -> (usize, Option<usize>) {
-				self.0.size_hint()
-			}
-			fn next_task(&mut self) -> Option<Self::Task> {
-				self.0
-					.next_task()
-					.map(|task| ConnectTask(task, self.1.task(), self.2.task(), PhantomData))
-			}
-		}
-		#[derive(Serialize, Deserialize)]
-		#[serde(
-			bound(serialize = "A: Serialize, B: Serialize, C: Serialize"),
-			bound(deserialize = "A: Deserialize<'de>, B: Deserialize<'de>, C: Deserialize<'de>")
-		)]
-		struct ConnectTask<A, B, C, RefAItem>(A, B, C, PhantomData<fn() -> RefAItem>);
-		impl<A, B, C, RefAItem> StreamTask for ConnectTask<A, B, C, RefAItem>
-		where
-			A: StreamTask,
-			B: PipeTask<A::Item>,
-			C: PipeTask<RefAItem>,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			type Async = ConnectStreamTaskAsync<A::Async, B::Async, C::Async, RefAItem, A::Item>;
-			fn into_async(self) -> Self::Async {
-				ConnectStreamTaskAsync(
-					self.0.into_async(),
-					self.1.into_async(),
-					self.2.into_async(),
-					false,
-					None,
-					PhantomData,
-				)
-			}
-		}
-		#[pin_project]
-		struct ConnectStreamTaskAsync<A, B, C, RefAItem, T>(
-			#[pin] A,
-			#[pin] B,
-			#[pin] C,
-			bool,
-			Option<Option<T>>,
-			PhantomData<fn() -> RefAItem>,
-		);
-		impl<A, B, C, RefAItem> StreamTaskAsync for ConnectStreamTaskAsync<A, B, C, RefAItem, A::Item>
-		where
-			A: StreamTaskAsync,
-			B: PipeTaskAsync<A::Item>,
-			C: PipeTaskAsync<RefAItem>,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			fn poll_run(
-				self: Pin<&mut Self>, cx: &mut Context,
-				sink: Pin<&mut impl Sink<Item = Self::Item>>,
-			) -> Poll<()> {
-				#[pin_project]
-				pub struct SinkFn<'a, S, A, B, T, RefAItem>(
-					#[pin] S,
-					Pin<&'a mut A>,
-					Pin<&'a mut B>,
-					&'a mut bool,
-					&'a mut Option<Option<T>>,
-					PhantomData<fn() -> (T, RefAItem)>,
-				);
-				impl<'a, S, A, B, T, RefAItem> Sink for SinkFn<'a, S, A, B, T, RefAItem>
-				where
-					S: Sink<Item = Sum2<A::Item, B::Item>>,
-					A: PipeTaskAsync<T>,
-					B: PipeTaskAsync<RefAItem>,
-				{
-					type Item = T;
-
-					fn poll_forward(
-						self: Pin<&mut Self>, cx: &mut Context,
-						mut stream: Pin<&mut impl Stream<Item = T>>,
-					) -> Poll<()> {
-						let mut self_ = self.project();
-						let mut ready = (false, false);
-						loop {
-							if self_.4.is_none() {
-								**self_.4 = match stream.as_mut().poll_next(cx) {
-									Poll::Ready(x) => Some(x),
-									Poll::Pending => None,
-								};
-							}
-							let given = &mut **self_.3;
-							let pending = &mut **self_.4;
-							let mut progress = false;
-							if !ready.0 {
-								let stream = stream::poll_fn(|_cx| match pending {
-									Some(x) if !*given => {
-										*given = true;
-										progress = true;
-										Poll::Ready(type_coerce(x.as_ref()))
-									}
-									_ => Poll::Pending,
-								})
-								.fuse();
-								pin_mut!(stream);
-								let sink_ = SinkMap::new(self_.0.as_mut(), |item| {
-									Sum2::B(type_coerce(item))
-								});
-								pin_mut!(sink_);
-								ready.0 = self_.2.as_mut().poll_run(cx, stream, sink_).is_ready();
-							}
-							if !ready.1 {
-								let stream = stream::poll_fn(|_cx| {
-									if !ready.0 && !*given {
-										return Poll::Pending;
-									}
-									match pending.take() {
-										Some(x) => {
-											*given = false;
-											progress = true;
-											Poll::Ready(x)
-										}
-										None => Poll::Pending,
-									}
-								})
-								.fuse();
-								pin_mut!(stream);
-								let sink_ = SinkMap::new(self_.0.as_mut(), Sum2::A);
-								pin_mut!(sink_);
-								ready.1 = self_.1.as_mut().poll_run(cx, stream, sink_).is_ready();
-							}
-							if ready.0 && ready.1 {
-								break Poll::Ready(());
-							}
-							if !progress {
-								break Poll::Pending;
-							}
-						}
-					}
-				}
-
-				let self_ = self.project();
-				let sink = SinkFn(sink, self_.1, self_.2, self_.3, self_.4, PhantomData);
-				pin_mut!(sink);
-				self_.0.poll_run(cx, sink)
-			}
-		}
-
 		let (iterator_a, reducer_a_a, reducer_a_b, reducer_a_c) = sink_a.reducers();
 		let (iterator_b, reducer_b_a, reducer_b_b, reducer_b_c) = sink_b.reducers();
-		Connect(self, iterator_a, iterator_b, PhantomData)
+		Fork::new(self, iterator_a, iterator_b)
 			.reduce(
 				pool,
-				ReduceA2Factory(reducer_a_a, reducer_b_a),
-				ReduceC2Factory(reducer_a_b, reducer_b_b),
+				ReduceA2::new(reducer_a_a, reducer_b_a),
+				ReduceC2::new(reducer_a_b, reducer_b_b),
 				ReduceC2::new(reducer_a_c, reducer_b_c),
 			)
 			.await
@@ -608,21 +322,23 @@ pub trait DistributedStream {
 		.await
 	}
 
-	async fn group_by<P, A, B, ID, F, C>(self, pool: &P, identity: ID, op: F) -> HashMap<A, C>
+	async fn group_by<P, S, A, B>(self, pool: &P, sink: S) -> HashMap<A, S::Output>
 	where
 		P: ProcessPool,
 		A: Eq + Hash + ProcessSend + 'static,
 		B: 'static,
-		ID: FnMut() -> C + Clone + ProcessSend + 'static,
-		F: FnMut(C, Either<B, C>) -> C + Clone + ProcessSend + 'static,
-		C: ProcessSend + 'static,
-		Self::Item: 'static,
+		S: DistributedSink<B>,
+		<S::Pipe as DistributedPipe<B>>::Task: Clone + ProcessSend + 'static,
+		S::ReduceA: 'static,
+		S::ReduceB: 'static,
+		S::ReduceC: Clone,
+		S::Output: ProcessSend + 'static,
 		Self::Task: 'static,
 		Self: DistributedStream<Item = (A, B)> + Sized,
 	{
 		self.pipe(
 			pool,
-			DistributedPipe::<Self::Item>::group_by(Identity, identity, op),
+			DistributedPipe::<Self::Item>::group_by(Identity, sink),
 		)
 		.await
 	}
@@ -828,7 +544,6 @@ pub trait DistributedStream {
 	where
 		P: ProcessPool,
 		B: FromDistributedStream<Self::Item>,
-		B::ReduceAFactory: ProcessSend + 'static,
 		B::ReduceA: ProcessSend + 'static,
 		B::ReduceB: ProcessSend + 'static,
 		Self::Task: 'static,
@@ -885,10 +600,9 @@ pub trait ParallelStream {
 		assert_parallel_stream(FlatMap::new(self, f))
 	}
 
-	fn filter<F, Fut>(self, f: F) -> Filter<Self, F>
+	fn filter<F>(self, f: F) -> Filter<Self, F>
 	where
-		F: FnMut(&Self::Item) -> Fut + Clone + Send + 'static,
-		Fut: Future<Output = bool>,
+		F: FnMut(&Self::Item) -> bool + Clone + Send + 'static,
 		Self: Sized,
 	{
 		assert_parallel_stream(Filter::new(self, f))
@@ -902,12 +616,11 @@ pub trait ParallelStream {
 	// 	assert_parallel_stream(Chain::new(self, chain.into_par_stream()))
 	// }
 
-	async fn reduce<P, B, R1F, R1, R3>(mut self, pool: &P, reduce_a_factory: R1F, reduce_c: R3) -> B
+	async fn reduce<P, B, R1, R3>(mut self, pool: &P, reduce_a_factory: R1, reduce_c: R3) -> B
 	where
 		P: ThreadPool,
-		R1F: Factory<Item = R1>,
-		R1: ReducerSend<Item = Self::Item> + Send + 'static,
-		R3: Reducer<Item = <R1 as ReducerSend>::Output, Output = B>,
+		R1: ReducerSend<Self::Item> + Clone + Send + 'static,
+		R3: Reducer<<R1 as ReducerSend<Self::Item>>::Output, Output = B>,
 		Self::Task: 'static,
 		Self: Sized,
 	{
@@ -957,39 +670,17 @@ pub trait ParallelStream {
 			.into_iter()
 			.filter(|tasks| !tasks.is_empty())
 			.map(|tasks| {
-				let reduce_a = reduce_a_factory.make();
+				let reduce_a = reduce_a_factory.clone();
 				pool.spawn(FnOnce!(move || {
-					#[pin_project]
-					struct Connect<B>(#[pin] B);
-					impl<B> Sink for Connect<B>
-					where
-						B: ReducerAsync,
-					{
-						type Item = B::Item;
-
-						fn poll_forward(
-							self: Pin<&mut Self>, cx: &mut Context,
-							stream: Pin<&mut impl Stream<Item = B::Item>>,
-						) -> Poll<()> {
-							let self_ = self.project();
-							self_.0.poll_forward(cx, stream)
-						}
-					}
-
-					let sink = Connect(reduce_a.into_async());
 					async move {
+						let sink = reduce_a.into_async();
 						pin_mut!(sink);
 						// TODO: short circuit
 						for task in tasks {
 							let task = task.into_async();
-							pin_mut!(task);
-							futures::future::poll_fn(|cx| task.as_mut().poll_run(cx, sink.as_mut()))
-								.await
+							task.sink(sink.as_mut()).await;
 						}
-						futures::future::poll_fn(|cx| {
-							sink.as_mut().project().0.as_mut().poll_output(cx)
-						})
-						.await
+						sink.output().await
 					}
 				}))
 			})
@@ -997,14 +688,10 @@ pub trait ParallelStream {
 		let stream = handles.map(|item| {
 			item.unwrap_or_else(|err| panic!("Amadeus: task '<unnamed>' panicked at '{}'", err))
 		});
-		pin_mut!(stream);
 		let reduce_c = reduce_c.into_async();
 		pin_mut!(reduce_c);
-		futures::future::poll_fn(|cx| {
-			ready!(reduce_c.as_mut().poll_forward(cx, stream.as_mut()));
-			reduce_c.as_mut().poll_output(cx)
-		})
-		.await
+		stream.sink(reduce_c.as_mut()).await;
+		reduce_c.output().await
 	}
 
 	async fn pipe<P, ParSink, A>(self, pool: &P, sink: ParSink) -> A
@@ -1016,69 +703,8 @@ pub trait ParallelStream {
 		Self::Task: 'static,
 		Self: Sized,
 	{
-		struct Connect<A, B>(A, B);
-		impl<A: ParallelStream, B: ParallelPipe<A::Item>> ParallelStream for Connect<A, B> {
-			type Item = B::Item;
-			type Task = ConnectTask<A::Task, B::Task>;
-			fn size_hint(&self) -> (usize, Option<usize>) {
-				self.0.size_hint()
-			}
-			fn next_task(&mut self) -> Option<Self::Task> {
-				self.0
-					.next_task()
-					.map(|task| ConnectTask(task, self.1.task()))
-			}
-		}
-		struct ConnectTask<A, B>(A, B);
-		impl<A, B> StreamTask for ConnectTask<A, B>
-		where
-			A: StreamTask,
-			B: PipeTask<A::Item>,
-		{
-			type Item = B::Item;
-			type Async = ConnectStreamTaskAsync<A::Async, B::Async>;
-			fn into_async(self) -> Self::Async {
-				ConnectStreamTaskAsync(self.0.into_async(), self.1.into_async())
-			}
-		}
-		#[pin_project]
-		struct ConnectStreamTaskAsync<A, B>(#[pin] A, #[pin] B);
-		impl<A, B> StreamTaskAsync for ConnectStreamTaskAsync<A, B>
-		where
-			A: StreamTaskAsync,
-			B: PipeTaskAsync<A::Item>,
-		{
-			type Item = B::Item;
-			fn poll_run(
-				self: Pin<&mut Self>, cx: &mut Context,
-				sink: Pin<&mut impl Sink<Item = Self::Item>>,
-			) -> Poll<()> {
-				#[pin_project]
-				struct Proxy<'a, I, B, Item>(#[pin] I, Pin<&'a mut B>, PhantomData<fn() -> Item>);
-				impl<'a, I, B, Item> Sink for Proxy<'a, I, B, Item>
-				where
-					I: Sink<Item = B::Item>,
-					B: PipeTaskAsync<Item>,
-				{
-					type Item = Item;
-
-					fn poll_forward(
-						self: Pin<&mut Self>, cx: &mut Context,
-						stream: Pin<&mut impl Stream<Item = Self::Item>>,
-					) -> Poll<()> {
-						let self_ = self.project();
-						self_.1.as_mut().poll_run(cx, stream, self_.0)
-					}
-				}
-				let self_ = self.project();
-				let sink = Proxy(sink, self_.1, PhantomData);
-				pin_mut!(sink);
-				self_.0.poll_run(cx, sink)
-			}
-		}
-
 		let (iterator, reducer_a, reducer_b) = sink.reducers();
-		Connect(self, iterator)
+		Pipe::new(self, iterator)
 			.reduce(pool, reducer_a, reducer_b)
 			.await
 	}
@@ -1101,160 +727,12 @@ pub trait ParallelStream {
 		Self::Task: 'static,
 		Self: Sized,
 	{
-		struct Connect<A, B, C, RefAItem>(A, B, C, PhantomData<fn() -> RefAItem>);
-		impl<A, B, C, RefAItem> ParallelStream for Connect<A, B, C, RefAItem>
-		where
-			A: ParallelStream,
-			B: ParallelPipe<A::Item>,
-			C: ParallelPipe<RefAItem>,
-			B::Task: 'static,
-			C::Task: 'static,
-			RefAItem: 'static,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			type Task = ConnectTask<A::Task, B::Task, C::Task, RefAItem>;
-			fn size_hint(&self) -> (usize, Option<usize>) {
-				self.0.size_hint()
-			}
-			fn next_task(&mut self) -> Option<Self::Task> {
-				self.0
-					.next_task()
-					.map(|task| ConnectTask(task, self.1.task(), self.2.task(), PhantomData))
-			}
-		}
-		struct ConnectTask<A, B, C, RefAItem>(A, B, C, PhantomData<fn() -> RefAItem>);
-		impl<A, B, C, RefAItem> StreamTask for ConnectTask<A, B, C, RefAItem>
-		where
-			A: StreamTask,
-			B: PipeTask<A::Item>,
-			C: PipeTask<RefAItem>,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			type Async = ConnectStreamTaskAsync<A::Async, B::Async, C::Async, RefAItem, A::Item>;
-			fn into_async(self) -> Self::Async {
-				ConnectStreamTaskAsync(
-					self.0.into_async(),
-					self.1.into_async(),
-					self.2.into_async(),
-					false,
-					None,
-					PhantomData,
-				)
-			}
-		}
-		#[pin_project]
-		struct ConnectStreamTaskAsync<A, B, C, RefAItem, T>(
-			#[pin] A,
-			#[pin] B,
-			#[pin] C,
-			bool,
-			Option<Option<T>>,
-			PhantomData<fn() -> RefAItem>,
-		);
-		impl<A, B, C, RefAItem> StreamTaskAsync for ConnectStreamTaskAsync<A, B, C, RefAItem, A::Item>
-		where
-			A: StreamTaskAsync,
-			B: PipeTaskAsync<A::Item>,
-			C: PipeTaskAsync<RefAItem>,
-		{
-			type Item = Sum2<B::Item, C::Item>;
-			fn poll_run(
-				self: Pin<&mut Self>, cx: &mut Context,
-				sink: Pin<&mut impl Sink<Item = Self::Item>>,
-			) -> Poll<()> {
-				#[pin_project]
-				pub struct SinkFn<'a, S, A, B, T, RefAItem>(
-					#[pin] S,
-					Pin<&'a mut A>,
-					Pin<&'a mut B>,
-					&'a mut bool,
-					&'a mut Option<Option<T>>,
-					PhantomData<fn() -> (T, RefAItem)>,
-				);
-				impl<'a, S, A, B, T, RefAItem> Sink for SinkFn<'a, S, A, B, T, RefAItem>
-				where
-					S: Sink<Item = Sum2<A::Item, B::Item>>,
-					A: PipeTaskAsync<T>,
-					B: PipeTaskAsync<RefAItem>,
-				{
-					type Item = T;
-
-					fn poll_forward(
-						self: Pin<&mut Self>, cx: &mut Context,
-						mut stream: Pin<&mut impl Stream<Item = T>>,
-					) -> Poll<()> {
-						let mut self_ = self.project();
-						let mut ready = (false, false);
-						loop {
-							if self_.4.is_none() {
-								**self_.4 = match stream.as_mut().poll_next(cx) {
-									Poll::Ready(x) => Some(x),
-									Poll::Pending => None,
-								};
-							}
-							let given = &mut **self_.3;
-							let pending = &mut **self_.4;
-							let mut progress = false;
-							if !ready.0 {
-								let stream = stream::poll_fn(|_cx| match pending {
-									Some(x) if !*given => {
-										*given = true;
-										progress = true;
-										Poll::Ready(type_coerce(x.as_ref()))
-									}
-									_ => Poll::Pending,
-								})
-								.fuse();
-								pin_mut!(stream);
-								let sink_ = SinkMap::new(self_.0.as_mut(), |item| {
-									Sum2::B(type_coerce(item))
-								});
-								pin_mut!(sink_);
-								ready.0 = self_.2.as_mut().poll_run(cx, stream, sink_).is_ready();
-							}
-							if !ready.1 {
-								let stream = stream::poll_fn(|_cx| {
-									if !ready.0 && !*given {
-										return Poll::Pending;
-									}
-									match pending.take() {
-										Some(x) => {
-											*given = false;
-											progress = true;
-											Poll::Ready(x)
-										}
-										None => Poll::Pending,
-									}
-								})
-								.fuse();
-								pin_mut!(stream);
-								let sink_ = SinkMap::new(self_.0.as_mut(), Sum2::A);
-								pin_mut!(sink_);
-								ready.1 = self_.1.as_mut().poll_run(cx, stream, sink_).is_ready();
-							}
-							if ready.0 && ready.1 {
-								break Poll::Ready(());
-							}
-							if !progress {
-								break Poll::Pending;
-							}
-						}
-					}
-				}
-
-				let self_ = self.project();
-				let sink = SinkFn(sink, self_.1, self_.2, self_.3, self_.4, PhantomData);
-				pin_mut!(sink);
-				self_.0.poll_run(cx, sink)
-			}
-		}
-
 		let (iterator_a, reducer_a_a, reducer_a_b) = sink_a.reducers();
 		let (iterator_b, reducer_b_a, reducer_b_b) = sink_b.reducers();
-		Connect(self, iterator_a, iterator_b, PhantomData)
+		Fork::new(self, iterator_a, iterator_b)
 			.reduce(
 				pool,
-				ReduceA2Factory(reducer_a_a, reducer_b_a),
+				ReduceA2::new(reducer_a_a, reducer_b_a),
 				ReduceC2::new(reducer_a_b, reducer_b_b),
 			)
 			.await
@@ -1289,23 +767,21 @@ pub trait ParallelStream {
 		.await
 	}
 
-	async fn group_by<P, A, B, ID, F, C>(self, pool: &P, identity: ID, op: F) -> HashMap<A, C>
+	async fn group_by<P, S, A, B>(self, pool: &P, sink: S) -> HashMap<A, S::Output>
 	where
 		P: ThreadPool,
 		A: Eq + Hash + Send + 'static,
 		B: 'static,
-		ID: FnMut() -> C + Clone + Send + 'static,
-		F: FnMut(C, Either<B, C>) -> C + Clone + Send + 'static,
-		C: Send + 'static,
-		Self::Item: 'static,
+		S: ParallelSink<B>,
+		<S::Pipe as ParallelPipe<B>>::Task: Clone + Send + 'static,
+		S::ReduceA: 'static,
+		S::ReduceC: Clone,
+		S::Output: Send + 'static,
 		Self::Task: 'static,
 		Self: ParallelStream<Item = (A, B)> + Sized,
 	{
-		self.pipe(
-			pool,
-			ParallelPipe::<Self::Item>::group_by(Identity, identity, op),
-		)
-		.await
+		self.pipe(pool, ParallelPipe::<Self::Item>::group_by(Identity, sink))
+			.await
 	}
 
 	async fn histogram<P>(self, pool: &P) -> Vec<(Self::Item, usize)>
diff --git a/amadeus-core/src/par_stream/chain.rs b/amadeus-core/src/par_stream/chain.rs
index 74985394..13a52cf4 100644
--- a/amadeus-core/src/par_stream/chain.rs
+++ b/amadeus-core/src/par_stream/chain.rs
@@ -1,12 +1,12 @@
 use derive_new::new;
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
 	pin::Pin, task::{Context, Poll}
 };
 
-use super::{ParallelStream, StreamTask, StreamTaskAsync};
-use crate::sink::Sink;
+use super::{ParallelStream, StreamTask};
 
 #[derive(new)]
 #[must_use]
@@ -57,15 +57,13 @@ impl<A: StreamTask, B: StreamTask<Item = A::Item>> StreamTask for ChainTask<A, B
 		}
 	}
 }
-impl<A: StreamTaskAsync, B: StreamTaskAsync<Item = A::Item>> StreamTaskAsync for ChainTask<A, B> {
+impl<A: Stream, B: Stream<Item = A::Item>> Stream for ChainTask<A, B> {
 	type Item = A::Item;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
 		match self.project() {
-			ChainTaskProj::A(a) => a.poll_run(cx, sink),
-			ChainTaskProj::B(b) => b.poll_run(cx, sink),
+			ChainTaskProj::A(a) => a.poll_next(cx),
+			ChainTaskProj::B(b) => b.poll_next(cx),
 		}
 	}
 }
diff --git a/amadeus-core/src/par_stream/cloned.rs b/amadeus-core/src/par_stream/cloned.rs
index 0ccec5b1..281ee8d7 100644
--- a/amadeus-core/src/par_stream/cloned.rs
+++ b/amadeus-core/src/par_stream/cloned.rs
@@ -1,13 +1,13 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
 	marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
-use super::{ParallelPipe, PipeTask, PipeTaskAsync};
-use crate::sink::{Sink, SinkMap};
+use super::{ParallelPipe, PipeTask};
+use crate::pipe::Pipe;
 
 #[derive(new)]
 #[must_use]
@@ -64,6 +64,7 @@ where
 {
 	type Item = T;
 	type Async = ClonedTask<C::Async>;
+
 	fn into_async(self) -> Self::Async {
 		ClonedTask {
 			task: self.task.into_async(),
@@ -80,19 +81,19 @@ where
 // 		self.task.run(&mut |item| i(item.clone()))
 // 	}
 // }
-impl<'a, C, Source: 'a, T: 'a> PipeTaskAsync<&'a Source> for ClonedTask<C>
+impl<'a, C, Source: 'a, T: 'a> Pipe<&'a Source> for ClonedTask<C>
 where
-	C: PipeTaskAsync<&'a Source, Item = &'a T>,
+	C: Pipe<&'a Source, Item = &'a T>,
 	T: Clone,
 {
 	type Item = T;
 
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = &'a Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let sink = SinkMap::new(sink, |item: &T| item.clone());
-		pin_mut!(sink);
-		self.project().task.poll_run(cx, stream, sink)
+	) -> Poll<Option<Self::Item>> {
+		self.project()
+			.task
+			.poll_next(cx, stream)
+			.map(Option::<&_>::cloned)
 	}
 }
diff --git a/amadeus-core/src/par_stream/filter.rs b/amadeus-core/src/par_stream/filter.rs
index a42ad9e4..d3b2fd5a 100644
--- a/amadeus-core/src/par_stream/filter.rs
+++ b/amadeus-core/src/par_stream/filter.rs
@@ -1,13 +1,8 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
-use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
-use std::{
-	future::Future, pin::Pin, task::{Context, Poll}
-};
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::{Sink, SinkFilter, SinkFilterState};
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::{Pipe, StreamExt};
 
 #[derive(new)]
 #[must_use]
@@ -17,10 +12,9 @@ pub struct Filter<I, F> {
 }
 
 impl_par_dist! {
-	impl<I: ParallelStream, F, Fut> ParallelStream for Filter<I, F>
+	impl<I: ParallelStream, F> ParallelStream for Filter<I, F>
 	where
-		F: FnMut(&I::Item) -> Fut + Clone + Send + 'static,
-		Fut: Future<Output = bool>,
+		F: FnMut(&I::Item) -> bool + Clone + Send + 'static,
 	{
 		type Item = I::Item;
 		type Task = FilterTask<I::Task, F>;
@@ -36,10 +30,9 @@ impl_par_dist! {
 		}
 	}
 
-	impl<I: ParallelPipe<Source>, F, Fut, Source> ParallelPipe<Source> for Filter<I, F>
+	impl<I: ParallelPipe<Source>, F, Source> ParallelPipe<Source> for Filter<I, F>
 	where
-		F: FnMut(&<I as ParallelPipe<Source>>::Item) -> Fut + Clone + Send + 'static,
-		Fut: Future<Output = bool>,
+		F: FnMut(&I::Item) -> bool + Clone + Send + 'static,
 	{
 		type Item = I::Item;
 		type Task = FilterTask<I::Task, F>;
@@ -58,80 +51,25 @@ pub struct FilterTask<C, F> {
 	f: F,
 }
 
-impl<C: StreamTask, F, Fut> StreamTask for FilterTask<C, F>
+impl<C: StreamTask, F> StreamTask for FilterTask<C, F>
 where
-	F: FnMut(&C::Item) -> Fut + Clone,
-	Fut: Future<Output = bool>,
+	F: FnMut(&C::Item) -> bool,
 {
 	type Item = C::Item;
-	type Async = FilterStreamTaskAsync<C::Async, F, Self::Item, Fut>;
-	fn into_async(self) -> Self::Async {
-		FilterStreamTaskAsync {
-			task: self.task.into_async(),
-			f: self.f,
-			state: SinkFilterState::None,
-		}
-	}
-}
-impl<C: PipeTask<Source>, F, Fut, Source> PipeTask<Source> for FilterTask<C, F>
-where
-	F: FnMut(&C::Item) -> Fut + Clone,
-	Fut: Future<Output = bool>,
-{
-	type Item = C::Item;
-	type Async = FilterStreamTaskAsync<C::Async, F, Self::Item, Fut>;
-	fn into_async(self) -> Self::Async {
-		FilterStreamTaskAsync {
-			task: self.task.into_async(),
-			f: self.f,
-			state: SinkFilterState::None,
-		}
-	}
-}
+	type Async = crate::pipe::Filter<C::Async, F>;
 
-#[pin_project]
-pub struct FilterStreamTaskAsync<C, F, T, Fut> {
-	#[pin]
-	task: C,
-	f: F,
-	#[pin]
-	state: SinkFilterState<T, Fut>,
-}
-
-impl<C: StreamTaskAsync, F, Fut> StreamTaskAsync for FilterStreamTaskAsync<C, F, C::Item, Fut>
-where
-	F: FnMut(&C::Item) -> Fut + Clone,
-	Fut: Future<Output = bool>,
-{
-	type Item = C::Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let mut self_ = self.project();
-		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkFilter::new(self_.state, sink, |item: &_| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, sink)
+	fn into_async(self) -> Self::Async {
+		self.task.into_async().filter(self.f)
 	}
 }
-
-impl<C: PipeTaskAsync<Source>, F, Fut, Source> PipeTaskAsync<Source>
-	for FilterStreamTaskAsync<C, F, C::Item, Fut>
+impl<C: PipeTask<Source>, F, Source> PipeTask<Source> for FilterTask<C, F>
 where
-	F: FnMut(&<C as PipeTaskAsync<Source>>::Item) -> Fut + Clone,
-	Fut: Future<Output = bool>,
+	F: FnMut(&C::Item) -> bool,
 {
 	type Item = C::Item;
+	type Async = crate::pipe::Filter<C::Async, F>;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let mut self_ = self.project();
-		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkFilter::new(self_.state, sink, |item: &_| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, stream, sink)
+	fn into_async(self) -> Self::Async {
+		self.task.into_async().filter(self.f)
 	}
 }
diff --git a/amadeus-core/src/par_stream/flat_map.rs b/amadeus-core/src/par_stream/flat_map.rs
index 025c572a..9b52ff8e 100644
--- a/amadeus-core/src/par_stream/flat_map.rs
+++ b/amadeus-core/src/par_stream/flat_map.rs
@@ -1,13 +1,9 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
-use pin_project::pin_project;
+use futures::Stream;
 use serde::{Deserialize, Serialize};
-use std::{
-	pin::Pin, task::{Context, Poll}
-};
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::{Sink, SinkFlatMap};
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::{Pipe, StreamExt};
 
 #[derive(new)]
 #[must_use]
@@ -37,7 +33,7 @@ impl_par_dist! {
 
 	impl<I: ParallelPipe<Source>, F, R: Stream, Source> ParallelPipe<Source> for FlatMap<I, F>
 	where
-		F: FnMut(<I as ParallelPipe<Source>>::Item) -> R + Clone + Send + 'static,
+		F: FnMut(I::Item) -> R + Clone + Send + 'static,
 	{
 		type Item = R::Item;
 		type Task = FlatMapTask<I::Task, F>;
@@ -57,70 +53,19 @@ pub struct FlatMapTask<C, F> {
 }
 impl<C: StreamTask, F: FnMut(C::Item) -> R + Clone, R: Stream> StreamTask for FlatMapTask<C, F> {
 	type Item = R::Item;
-	type Async = FlatMapStreamTaskAsync<C::Async, F, R>;
+	type Async = crate::pipe::FlatMap<C::Async, F, R>;
+
 	fn into_async(self) -> Self::Async {
-		FlatMapStreamTaskAsync {
-			task: self.task.into_async(),
-			f: self.f,
-			fut: None,
-		}
+		self.task.into_async().flat_map(self.f)
 	}
 }
 impl<C: PipeTask<Source>, F: FnMut(C::Item) -> R + Clone, R: Stream, Source> PipeTask<Source>
 	for FlatMapTask<C, F>
 {
 	type Item = R::Item;
-	type Async = FlatMapStreamTaskAsync<C::Async, F, R>;
-	fn into_async(self) -> Self::Async {
-		FlatMapStreamTaskAsync {
-			task: self.task.into_async(),
-			f: self.f,
-			fut: None,
-		}
-	}
-}
-
-#[pin_project]
-#[derive(Serialize, Deserialize)]
-pub struct FlatMapStreamTaskAsync<C, F, Fut> {
-	#[pin]
-	task: C,
-	f: F,
-	#[pin]
-	fut: Option<Fut>,
-}
-
-impl<C: StreamTaskAsync, F: FnMut(C::Item) -> R + Clone, R: Stream> StreamTaskAsync
-	for FlatMapStreamTaskAsync<C, F, R>
-{
-	type Item = R::Item;
+	type Async = crate::pipe::FlatMap<C::Async, F, R>;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let mut self_ = self.project();
-		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkFlatMap::new(self_.fut, sink, |item| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, sink)
-	}
-}
-
-impl<C: PipeTaskAsync<Source>, F, R: Stream, Source> PipeTaskAsync<Source>
-	for FlatMapStreamTaskAsync<C, F, R>
-where
-	F: FnMut(<C as PipeTaskAsync<Source>>::Item) -> R + Clone,
-{
-	type Item = R::Item;
-
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let mut self_ = self.project();
-		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkFlatMap::new(self_.fut, sink, |item| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, stream, sink)
+	fn into_async(self) -> Self::Async {
+		self.task.into_async().flat_map(self.f)
 	}
 }
diff --git a/amadeus-core/src/par_stream/identity.rs b/amadeus-core/src/par_stream/identity.rs
index a50f8f50..8ccc351d 100644
--- a/amadeus-core/src/par_stream/identity.rs
+++ b/amadeus-core/src/par_stream/identity.rs
@@ -5,12 +5,12 @@ use std::{
 };
 
 use super::{
-	All, Any, Collect, Combine, Count, Filter, FlatMap, Fold, ForEach, GroupBy, Histogram, Inspect, Map, Max, MaxBy, MaxByKey, Min, MinBy, MinByKey, MostDistinct, MostFrequent, ParallelPipe, Pipe, PipeTask, PipeTaskAsync, SampleUnstable, Sum, Update
+	All, Any, Collect, Combine, Count, Filter, FlatMap, Fold, ForEach, Fork, GroupBy, Histogram, Inspect, Map, Max, MaxBy, MaxByKey, Min, MinBy, MinByKey, MostDistinct, MostFrequent, ParallelPipe, Pipe, PipeTask, SampleUnstable, Sum, Update
 };
-use crate::sink::Sink;
 
 // TODO: add type parameter to Identity when type the type system includes HRTB in the ParallelPipe impl https://github.com/dtolnay/ghost/
 
+#[derive(Clone, Copy, Debug)]
 pub struct Identity;
 
 impl_par_dist! {
@@ -34,6 +34,10 @@ mod workaround {
 			Pipe::new(self, sink)
 		}
 
+		pub fn fork<A, B, RefAItem>(self, sink: A, sink_ref: B) -> Fork<Self, A, B, RefAItem> {
+			Fork::new(self, sink, sink_ref)
+		}
+
 		pub fn inspect<F>(self, f: F) -> Inspect<Self, F>
 		where
 			F: Clone + Send + 'static,
@@ -93,12 +97,8 @@ mod workaround {
 			Fold::new(self, identity, op)
 		}
 
-		pub fn group_by<ID, F, C>(self, identity: ID, op: F) -> GroupBy<Self, ID, F, C>
-		where
-			ID: FnMut() -> C + Clone + Send + 'static,
-			C: Send + 'static,
-		{
-			GroupBy::new(self, identity, op)
+		pub fn group_by<S>(self, sink: S) -> GroupBy<Self, S> {
+			GroupBy::new(self, sink)
 		}
 
 		pub fn histogram(self) -> Histogram<Self> {
@@ -195,22 +195,22 @@ mod workaround {
 	}
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct IdentityTask;
 impl<Item> PipeTask<Item> for IdentityTask {
 	type Item = Item;
 	type Async = IdentityTask;
+
 	fn into_async(self) -> Self::Async {
 		IdentityTask
 	}
 }
-impl<Item> PipeTaskAsync<Item> for IdentityTask {
+impl<Item> crate::pipe::Pipe<Item> for IdentityTask {
 	type Item = Item;
 
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Item>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		sink.poll_forward(cx, stream)
+	) -> Poll<Option<Item>> {
+		stream.poll_next(cx)
 	}
 }
diff --git a/amadeus-core/src/par_stream/inspect.rs b/amadeus-core/src/par_stream/inspect.rs
index 8005ff4e..76b53aa6 100644
--- a/amadeus-core/src/par_stream/inspect.rs
+++ b/amadeus-core/src/par_stream/inspect.rs
@@ -1,13 +1,13 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
 	pin::Pin, task::{Context, Poll}
 };
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::{Sink, SinkMap};
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::Pipe;
 
 #[derive(new)]
 #[must_use]
@@ -37,7 +37,7 @@ impl_par_dist! {
 
 	impl<I: ParallelPipe<Source>, F, Source> ParallelPipe<Source> for Inspect<I, F>
 	where
-		F: FnMut(&<I as ParallelPipe<Source>>::Item) + Clone + Send + 'static,
+		F: FnMut(&I::Item) + Clone + Send + 'static,
 	{
 		type Item = I::Item;
 		type Task = InspectTask<I::Task, F>;
@@ -85,43 +85,40 @@ where
 	}
 }
 
-impl<C: StreamTaskAsync, F> StreamTaskAsync for InspectTask<C, F>
+impl<C: Stream, F> Stream for InspectTask<C, F>
 where
 	F: FnMut(&C::Item) + Clone,
 {
 	type Item = C::Item;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |item| {
-			f(&item);
-			item
-		});
-		pin_mut!(sink);
-		task.poll_run(cx, sink)
+		task.poll_next(cx).map(|item| {
+			item.map(|item| {
+				f(&item);
+				item
+			})
+		})
 	}
 }
 
-impl<C: PipeTaskAsync<Source>, F, Source> PipeTaskAsync<Source> for InspectTask<C, F>
+impl<C: Pipe<Source>, F, Source> Pipe<Source> for InspectTask<C, F>
 where
-	F: FnMut(&<C as PipeTaskAsync<Source>>::Item) + Clone,
+	F: FnMut(&C::Item) + Clone,
 {
 	type Item = C::Item;
 
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |item| {
-			f(&item);
-			item
-		});
-		pin_mut!(sink);
-		task.poll_run(cx, stream, sink)
+		task.poll_next(cx, stream).map(|item| {
+			item.map(|item| {
+				f(&item);
+				item
+			})
+		})
 	}
 }
diff --git a/amadeus-core/src/par_stream/map.rs b/amadeus-core/src/par_stream/map.rs
index f5a46c5f..14741260 100644
--- a/amadeus-core/src/par_stream/map.rs
+++ b/amadeus-core/src/par_stream/map.rs
@@ -1,13 +1,13 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
 	pin::Pin, task::{Context, Poll}
 };
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::{Sink, SinkMap};
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::Pipe;
 
 #[derive(new)]
 #[must_use]
@@ -37,7 +37,7 @@ impl_par_dist! {
 
 	impl<I: ParallelPipe<Source>, F, R, Source> ParallelPipe<Source> for Map<I, F>
 	where
-		F: FnMut(<I as ParallelPipe<Source>>::Item) -> R + Clone + Send + 'static,
+		F: FnMut(I::Item) -> R + Clone + Send + 'static,
 	{
 		type Item = R;
 		type Task = MapTask<I::Task, F>;
@@ -85,37 +85,30 @@ where
 	}
 }
 
-impl<C: StreamTaskAsync, F, R> StreamTaskAsync for MapTask<C, F>
+impl<C: Stream, F, R> Stream for MapTask<C, F>
 where
 	F: FnMut(C::Item) -> R + Clone,
 {
 	type Item = R;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |item| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, sink)
+		task.poll_next(cx).map(|t| t.map(f))
 	}
 }
 
-impl<C: PipeTaskAsync<Source>, F, R, Source> PipeTaskAsync<Source> for MapTask<C, F>
+impl<C: Pipe<Source>, F, R, Source> Pipe<Source> for MapTask<C, F>
 where
-	F: FnMut(<C as PipeTaskAsync<Source>>::Item) -> R + Clone,
+	F: FnMut(C::Item) -> R + Clone,
 {
 	type Item = R;
 
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |item| f(item));
-		pin_mut!(sink);
-		task.poll_run(cx, stream, sink)
+		task.poll_next(cx, stream).map(|t| t.map(f))
 	}
 }
diff --git a/amadeus-core/src/par_stream/sum_type.rs b/amadeus-core/src/par_stream/sum_type.rs
index df9f577f..8037d82d 100644
--- a/amadeus-core/src/par_stream/sum_type.rs
+++ b/amadeus-core/src/par_stream/sum_type.rs
@@ -4,8 +4,8 @@ use std::{
 };
 use sum::Sum2;
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::Sink;
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::Pipe;
 
 impl_par_dist! {
 	impl<A: ParallelStream, B: ParallelStream<Item = A::Item>> ParallelStream for Sum2<A, B> {
@@ -64,31 +64,15 @@ impl<A: PipeTask<Source>, B: PipeTask<Source, Item = A::Item>, Source> PipeTask<
 	}
 }
 
-impl<A: StreamTaskAsync, B: StreamTaskAsync<Item = A::Item>> StreamTaskAsync for Sum2<A, B> {
+impl<A: Pipe<Source>, B: Pipe<Source, Item = A::Item>, Source> Pipe<Source> for Sum2<A, B> {
 	type Item = A::Item;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		match self.as_pin_mut() {
-			Sum2::A(task) => task.poll_run(cx, sink),
-			Sum2::B(task) => task.poll_run(cx, sink),
-		}
-	}
-}
-
-impl<A: PipeTaskAsync<Source>, B: PipeTaskAsync<Source, Item = A::Item>, Source>
-	PipeTaskAsync<Source> for Sum2<A, B>
-{
-	type Item = A::Item;
-
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	) -> Poll<Option<Self::Item>> {
 		match self.as_pin_mut() {
-			Sum2::A(task) => task.poll_run(cx, stream, sink),
-			Sum2::B(task) => task.poll_run(cx, stream, sink),
+			Sum2::A(task) => task.poll_next(cx, stream),
+			Sum2::B(task) => task.poll_next(cx, stream),
 		}
 	}
 }
diff --git a/amadeus-core/src/par_stream/update.rs b/amadeus-core/src/par_stream/update.rs
index d6d8e943..9a4c1b85 100644
--- a/amadeus-core/src/par_stream/update.rs
+++ b/amadeus-core/src/par_stream/update.rs
@@ -1,13 +1,13 @@
 use derive_new::new;
-use futures::{pin_mut, Stream};
+use futures::Stream;
 use pin_project::pin_project;
 use serde::{Deserialize, Serialize};
 use std::{
 	pin::Pin, task::{Context, Poll}
 };
 
-use super::{ParallelPipe, ParallelStream, PipeTask, PipeTaskAsync, StreamTask, StreamTaskAsync};
-use crate::sink::{Sink, SinkMap};
+use super::{ParallelPipe, ParallelStream, PipeTask, StreamTask};
+use crate::pipe::Pipe;
 
 #[derive(new)]
 #[must_use]
@@ -37,7 +37,7 @@ impl_par_dist! {
 
 	impl<I: ParallelPipe<Source>, F, Source> ParallelPipe<Source> for Update<I, F>
 	where
-		F: FnMut(&mut <I as ParallelPipe<Source>>::Item) + Clone + Send + 'static,
+		F: FnMut(&mut I::Item) + Clone + Send + 'static,
 	{
 		type Item = I::Item;
 		type Task = UpdateTask<I::Task, F>;
@@ -85,43 +85,40 @@ where
 	}
 }
 
-impl<C: StreamTaskAsync, F> StreamTaskAsync for UpdateTask<C, F>
+impl<C: Stream, F> Stream for UpdateTask<C, F>
 where
 	F: FnMut(&mut C::Item) + Clone,
 {
 	type Item = C::Item;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context, sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |mut item| {
-			f(&mut item);
-			item
-		});
-		pin_mut!(sink);
-		task.poll_run(cx, sink)
+		task.poll_next(cx).map(|item| {
+			item.map(|mut item| {
+				f(&mut item);
+				item
+			})
+		})
 	}
 }
 
-impl<C: PipeTaskAsync<Source>, F, Source> PipeTaskAsync<Source> for UpdateTask<C, F>
+impl<C: Pipe<Source>, F, Source> Pipe<Source> for UpdateTask<C, F>
 where
-	F: FnMut(&mut <C as PipeTaskAsync<Source>>::Item) + Clone,
+	F: FnMut(&mut C::Item) + Clone,
 {
 	type Item = C::Item;
 
-	fn poll_run(
+	fn poll_next(
 		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
-		sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	) -> Poll<Option<Self::Item>> {
 		let mut self_ = self.project();
 		let (task, f) = (self_.task, &mut self_.f);
-		let sink = SinkMap::new(sink, |mut item| {
-			f(&mut item);
-			item
-		});
-		pin_mut!(sink);
-		task.poll_run(cx, stream, sink)
+		task.poll_next(cx, stream).map(|item| {
+			item.map(|mut item| {
+				f(&mut item);
+				item
+			})
+		})
 	}
 }
diff --git a/amadeus-core/src/pipe.rs b/amadeus-core/src/pipe.rs
new file mode 100644
index 00000000..44af5da4
--- /dev/null
+++ b/amadeus-core/src/pipe.rs
@@ -0,0 +1,262 @@
+mod filter;
+mod flat_map;
+
+use futures::{pin_mut, Future, Stream};
+use pin_project::pin_project;
+use std::{
+	ops::DerefMut, pin::Pin, task::{Context, Poll}
+};
+
+pub use self::{filter::*, flat_map::*};
+
+// Sink takes Source as an input parameter rather than associated type to accept
+// for<'a> &'a T, but this might not be necessary in future?
+// https://github.com/rust-lang/rust/issues/49601
+
+pub trait StreamExt: Stream {
+	fn pipe<P>(self, pipe: P) -> StreamPipe<Self, P>
+	where
+		P: Pipe<Self::Item>,
+		Self: Sized,
+	{
+		assert_stream(StreamPipe { stream: self, pipe })
+	}
+
+	fn sink<S>(self, sink: S) -> StreamSink<Self, S>
+	where
+		S: Sink<Self::Item>,
+		Self: Sized,
+	{
+		assert_future(StreamSink { stream: self, sink })
+	}
+
+	fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R>
+	where
+		F: FnMut(Self::Item) -> R,
+		R: Stream,
+		Self: Sized,
+	{
+		assert_stream(FlatMap::new(self, f))
+	}
+
+	fn filter<F>(self, f: F) -> Filter<Self, F>
+	where
+		F: FnMut(&Self::Item) -> bool,
+		Self: Sized,
+	{
+		assert_stream(Filter::new(self, f))
+	}
+}
+impl<S: ?Sized> StreamExt for S where S: Stream {}
+
+pub trait Pipe<Source> {
+	type Item;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>>;
+
+	fn pipe<P>(self, pipe: P) -> PipePipe<Self, P>
+	where
+		P: Pipe<Self::Item>,
+		Self: Sized,
+	{
+		assert_pipe(PipePipe { a: self, b: pipe })
+	}
+
+	fn sink<S>(self, sink: S) -> PipeSink<Self, S>
+	where
+		S: Sink<Self::Item>,
+		Self: Sized,
+	{
+		assert_sink(PipeSink { pipe: self, sink })
+	}
+
+	fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R>
+	where
+		F: FnMut(Self::Item) -> R,
+		R: Stream,
+		Self: Sized,
+	{
+		assert_pipe(FlatMap::new(self, f))
+	}
+
+	fn filter<F>(self, f: F) -> Filter<Self, F>
+	where
+		F: FnMut(&Self::Item) -> bool,
+		Self: Sized,
+	{
+		assert_pipe(Filter::new(self, f))
+	}
+}
+
+pub trait Sink<Source> {
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<()>;
+}
+
+fn assert_stream<S>(s: S) -> S
+where
+	S: Stream,
+{
+	s
+}
+fn assert_pipe<P, Source>(p: P) -> P
+where
+	P: Pipe<Source>,
+{
+	p
+}
+fn assert_sink<S, Source>(s: S) -> S
+where
+	S: Sink<Source>,
+{
+	s
+}
+fn assert_future<F>(f: F) -> F
+where
+	F: Future,
+{
+	f
+}
+
+#[pin_project]
+pub struct StreamPipe<S, P> {
+	#[pin]
+	stream: S,
+	#[pin]
+	pipe: P,
+}
+
+impl<S, P> Stream for StreamPipe<S, P>
+where
+	S: Stream,
+	P: Pipe<S::Item>,
+{
+	type Item = P::Item;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let self_ = self.project();
+		self_.pipe.poll_next(cx, self_.stream)
+	}
+}
+
+#[pin_project]
+pub struct PipePipe<A, B> {
+	#[pin]
+	a: A,
+	#[pin]
+	b: B,
+}
+
+impl<A, B, Source> Pipe<Source> for PipePipe<A, B>
+where
+	A: Pipe<Source>,
+	B: Pipe<A::Item>,
+{
+	type Item = B::Item;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		let self_ = self.project();
+		let stream = stream.pipe(self_.a);
+		pin_mut!(stream);
+		self_.b.poll_next(cx, stream)
+	}
+}
+
+#[pin_project]
+pub struct PipeSink<P, S> {
+	#[pin]
+	pipe: P,
+	#[pin]
+	sink: S,
+}
+
+impl<P, S, Source> Sink<Source> for PipeSink<P, S>
+where
+	P: Pipe<Source>,
+	S: Sink<P::Item>,
+{
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<()> {
+		let self_ = self.project();
+		let stream = stream.pipe(self_.pipe);
+		pin_mut!(stream);
+		self_.sink.poll_pipe(cx, stream)
+	}
+}
+
+#[pin_project]
+pub struct StreamSink<A, B> {
+	#[pin]
+	stream: A,
+	#[pin]
+	sink: B,
+}
+
+impl<A, B> Future for StreamSink<A, B>
+where
+	A: Stream,
+	B: Sink<A::Item>,
+{
+	type Output = ();
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<()> {
+		let self_ = self.project();
+		self_.sink.poll_pipe(cx, self_.stream)
+	}
+}
+
+impl<P, Source> Pipe<Source> for Pin<P>
+where
+	P: DerefMut + Unpin,
+	P::Target: Pipe<Source>,
+{
+	type Item = <P::Target as Pipe<Source>>::Item;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		self.get_mut().as_mut().poll_next(cx, stream)
+	}
+}
+
+impl<T: ?Sized, Source> Pipe<Source> for &mut T
+where
+	T: Pipe<Source> + Unpin,
+{
+	type Item = T::Item;
+
+	fn poll_next(
+		mut self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		Pin::new(&mut **self).poll_next(cx, stream)
+	}
+}
+
+impl<P, Source> Sink<Source> for Pin<P>
+where
+	P: DerefMut + Unpin,
+	P::Target: Sink<Source>,
+{
+	fn poll_pipe(
+		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<()> {
+		self.get_mut().as_mut().poll_pipe(cx, stream)
+	}
+}
+
+impl<T: ?Sized, Source> Sink<Source> for &mut T
+where
+	T: Sink<Source> + Unpin,
+{
+	fn poll_pipe(
+		mut self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<()> {
+		Pin::new(&mut **self).poll_pipe(cx, stream)
+	}
+}
diff --git a/amadeus-core/src/pipe/filter.rs b/amadeus-core/src/pipe/filter.rs
new file mode 100644
index 00000000..bba894cc
--- /dev/null
+++ b/amadeus-core/src/pipe/filter.rs
@@ -0,0 +1,56 @@
+use derive_new::new;
+use futures::{ready, Stream};
+use pin_project::pin_project;
+use std::{
+	pin::Pin, task::{Context, Poll}
+};
+
+use super::Pipe;
+
+#[pin_project]
+#[derive(new)]
+pub struct Filter<C, F> {
+	#[pin]
+	task: C,
+	f: F,
+}
+
+impl<C: Stream, F> Stream for Filter<C, F>
+where
+	F: FnMut(&C::Item) -> bool,
+{
+	type Item = C::Item;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		let (mut task, f) = (self_.task, &mut self_.f);
+		Poll::Ready(loop {
+			match ready!(task.as_mut().poll_next(cx)) {
+				Some(t) if f(&t) => break Some(t),
+				Some(_) => (),
+				None => break None,
+			}
+		})
+	}
+}
+
+impl<C: Pipe<Source>, F, Source> Pipe<Source> for Filter<C, F>
+where
+	F: FnMut(&C::Item) -> bool,
+{
+	type Item = C::Item;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		let (mut task, f) = (self_.task, &mut self_.f);
+		Poll::Ready(loop {
+			match ready!(task.as_mut().poll_next(cx, stream.as_mut())) {
+				Some(t) if f(&t) => break Some(t),
+				Some(_) => (),
+				None => break None,
+			}
+		})
+	}
+}
diff --git a/amadeus-core/src/pipe/flat_map.rs b/amadeus-core/src/pipe/flat_map.rs
new file mode 100644
index 00000000..d13dad4d
--- /dev/null
+++ b/amadeus-core/src/pipe/flat_map.rs
@@ -0,0 +1,71 @@
+use derive_new::new;
+use futures::{ready, Stream};
+use pin_project::pin_project;
+use std::{
+	pin::Pin, task::{Context, Poll}
+};
+
+use super::Pipe;
+
+#[pin_project]
+#[derive(new)]
+pub struct FlatMap<C, F, R> {
+	#[pin]
+	pipe: C,
+	f: F,
+	#[pin]
+	#[new(default)]
+	next: Option<R>,
+}
+
+impl<C: Stream, F, R> Stream for FlatMap<C, F, R>
+where
+	F: FnMut(C::Item) -> R,
+	R: Stream,
+{
+	type Item = R::Item;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		Poll::Ready(loop {
+			if let Some(s) = self_.next.as_mut().as_pin_mut() {
+				if let Some(item) = ready!(s.poll_next(cx)) {
+					break Some(item);
+				} else {
+					self_.next.set(None);
+				}
+			} else if let Some(s) = ready!(self_.pipe.as_mut().poll_next(cx)) {
+				self_.next.set(Some((self_.f)(s)));
+			} else {
+				break None;
+			}
+		})
+	}
+}
+
+impl<C: Pipe<Source>, F, R, Source> Pipe<Source> for FlatMap<C, F, R>
+where
+	F: FnMut(C::Item) -> R,
+	R: Stream,
+{
+	type Item = R::Item;
+
+	fn poll_next(
+		self: Pin<&mut Self>, cx: &mut Context, mut stream: Pin<&mut impl Stream<Item = Source>>,
+	) -> Poll<Option<Self::Item>> {
+		let mut self_ = self.project();
+		Poll::Ready(loop {
+			if let Some(s) = self_.next.as_mut().as_pin_mut() {
+				if let Some(item) = ready!(s.poll_next(cx)) {
+					break Some(item);
+				} else {
+					self_.next.set(None);
+				}
+			} else if let Some(s) = ready!(self_.pipe.as_mut().poll_next(cx, stream.as_mut())) {
+				self_.next.set(Some((self_.f)(s)));
+			} else {
+				break None;
+			}
+		})
+	}
+}
diff --git a/amadeus-core/src/sink.rs b/amadeus-core/src/sink.rs
deleted file mode 100644
index 92f7e68f..00000000
--- a/amadeus-core/src/sink.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-#![allow(clippy::type_complexity)]
-
-use derive_new::new;
-use futures::{pin_mut, ready, stream, Future, Stream, StreamExt};
-use pin_project::pin_project;
-use std::{
-	marker::PhantomData, ops::DerefMut, pin::Pin, task::{Context, Poll}
-};
-
-// Sink could take Item as an input parameter to accept for<'a> &'a T, but this might be fixed anyway? https://github.com/rust-lang/rust/issues/49601
-
-pub trait Sink {
-	type Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()>;
-}
-
-impl<P> Sink for Pin<P>
-where
-	P: DerefMut + Unpin,
-	P::Target: Sink,
-{
-	type Item = <P::Target as Sink>::Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		self.get_mut().as_mut().poll_forward(cx, stream)
-	}
-}
-
-impl<T: ?Sized> Sink for &mut T
-where
-	T: Sink + Unpin,
-{
-	type Item = T::Item;
-
-	fn poll_forward(
-		mut self: Pin<&mut Self>, cx: &mut Context,
-		stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		Pin::new(&mut **self).poll_forward(cx, stream)
-	}
-}
-
-#[pin_project]
-#[derive(new)]
-pub struct SinkMap<F, I, R, Item> {
-	#[pin]
-	i: I,
-	f: F,
-	marker: PhantomData<fn() -> (R, Item)>,
-}
-impl<F, I, R, Item> Sink for SinkMap<F, I, R, Item>
-where
-	F: FnMut(Item) -> R,
-	I: Sink<Item = R>,
-{
-	type Item = Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context, stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		let self_ = self.project();
-		let (f, i) = (self_.f, self_.i);
-		let stream = stream.map(f);
-		pin_mut!(stream);
-		i.poll_forward(cx, stream)
-	}
-}
-
-#[pin_project(project = SinkFilterStateProj, project_replace = SinkFilterStateProjOwn)]
-pub enum SinkFilterState<T, Fut> {
-	Some(T, #[pin] Fut),
-	None,
-}
-impl<T, Fut> SinkFilterState<T, Fut> {
-	fn fut(self: Pin<&mut Self>) -> Option<Pin<&mut Fut>> {
-		match self.project() {
-			SinkFilterStateProj::Some(_, fut) => Some(fut),
-			SinkFilterStateProj::None => None,
-		}
-	}
-	fn take(self: Pin<&mut Self>) -> Option<T> {
-		match self.project_replace(SinkFilterState::None) {
-			SinkFilterStateProjOwn::Some(t, _) => Some(t),
-			SinkFilterStateProjOwn::None => None,
-		}
-	}
-}
-#[pin_project]
-#[derive(new)]
-pub struct SinkFilter<'a, F, I, T, Fut> {
-	fut: Pin<&'a mut SinkFilterState<T, Fut>>,
-	#[pin]
-	i: I,
-	f: F,
-}
-impl<'a, F, I, Fut, Item> Sink for SinkFilter<'a, F, I, Item, Fut>
-where
-	F: FnMut(&Item) -> Fut,
-	Fut: Future<Output = bool>,
-	I: Sink<Item = Item>,
-{
-	type Item = Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		let self_ = self.project();
-		let f = self_.f;
-		let fut = self_.fut;
-		let stream = stream::poll_fn(move |cx| loop {
-			if fut.as_mut().fut().is_none() {
-				let item = ready!(stream.as_mut().poll_next(cx));
-				if item.is_none() {
-					break Poll::Ready(None);
-				}
-				let item = item.unwrap();
-				let fut_ = f(&item);
-				fut.set(SinkFilterState::Some(item, fut_));
-			}
-			let filter = ready!(fut.as_mut().fut().unwrap().poll(cx));
-			let item = fut.as_mut().take().unwrap();
-			if filter {
-				break Poll::Ready(Some(item));
-			}
-		});
-		pin_mut!(stream);
-		(self_.i).poll_forward(cx, stream)
-	}
-}
-
-#[pin_project]
-#[derive(new)]
-pub struct SinkThen<'a, F, I, Fut, R, Item> {
-	fut: Pin<&'a mut Option<Fut>>,
-	#[pin]
-	i: I,
-	f: F,
-	marker: PhantomData<fn(R, Item)>,
-}
-impl<'a, F, I, R, Fut, Item> Sink for SinkThen<'a, F, I, Fut, R, Item>
-where
-	F: FnMut(Item) -> Fut,
-	Fut: Future<Output = R>,
-	I: Sink<Item = R>,
-{
-	type Item = Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		let self_ = self.project();
-		let f = self_.f;
-		let fut = self_.fut;
-		let stream = stream::poll_fn(|cx| {
-			if fut.is_none() {
-				let item = ready!(stream.as_mut().poll_next(cx));
-				if item.is_none() {
-					return Poll::Ready(None);
-				}
-				fut.set(Some(f(item.unwrap())));
-			}
-			let item = ready!(fut.as_mut().as_pin_mut().unwrap().poll(cx));
-			fut.set(None);
-			Poll::Ready(Some(item))
-		});
-		pin_mut!(stream);
-		(self_.i).poll_forward(cx, stream)
-	}
-}
-
-#[pin_project]
-#[derive(new)]
-pub struct SinkFlatMap<'a, F, I, Fut, R, Item> {
-	fut: Pin<&'a mut Option<Fut>>,
-	#[pin]
-	i: I,
-	f: F,
-	marker: PhantomData<fn() -> (Fut, R, Item)>,
-}
-impl<'a, F, I, R, Fut, Item> Sink for SinkFlatMap<'a, F, I, Fut, R, Item>
-where
-	F: FnMut(Item) -> Fut,
-	Fut: Stream<Item = R>,
-	I: Sink<Item = R>,
-{
-	type Item = Item;
-
-	fn poll_forward(
-		self: Pin<&mut Self>, cx: &mut Context,
-		mut stream: Pin<&mut impl Stream<Item = Self::Item>>,
-	) -> Poll<()> {
-		let self_ = self.project();
-		let f = self_.f;
-		let fut = self_.fut;
-		let stream = stream::poll_fn(|cx| loop {
-			if fut.is_none() {
-				let item = ready!(stream.as_mut().poll_next(cx));
-				if item.is_none() {
-					return Poll::Ready(None);
-				}
-				fut.set(Some(f(item.unwrap())));
-			}
-			let item = ready!(fut.as_mut().as_pin_mut().unwrap().poll_next(cx));
-			if let Some(item) = item {
-				break Poll::Ready(Some(item));
-			}
-			fut.set(None);
-		});
-		pin_mut!(stream);
-		(self_.i).poll_forward(cx, stream)
-	}
-}
diff --git a/amadeus-core/src/util.rs b/amadeus-core/src/util.rs
index debb8b28..487d2b2f 100644
--- a/amadeus-core/src/util.rs
+++ b/amadeus-core/src/util.rs
@@ -3,12 +3,10 @@ use futures::{ready, Stream};
 use pin_project::pin_project;
 use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
 use std::{
-	any::type_name, error, fmt, hash::{Hash, Hasher}, io, marker::PhantomData, pin::Pin, sync::Arc, task::{Context, Poll}
+	error, fmt, hash::{Hash, Hasher}, io, marker::PhantomData, pin::Pin, sync::Arc, task::{Context, Poll}
 };
 
-use crate::{
-	par_stream::{DistributedStream, ParallelStream, StreamTask, StreamTaskAsync}, sink::Sink
-};
+use crate::par_stream::{DistributedStream, ParallelStream, StreamTask};
 
 pub struct ResultExpand<T, E>(pub Result<T, E>);
 impl<T, E> IntoIterator for ResultExpand<T, E>
@@ -155,12 +153,10 @@ where
 		self
 	}
 }
-impl<T: 'static> StreamTaskAsync for ImplTask<T> {
+impl<T: 'static> Stream for ImplTask<T> {
 	type Item = T;
 
-	fn poll_run(
-		self: Pin<&mut Self>, _cx: &mut Context, _sink: Pin<&mut impl Sink<Item = Self::Item>>,
-	) -> Poll<()> {
+	fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
 		unreachable!()
 	}
 }
@@ -222,51 +218,19 @@ where
 	}
 }
 
-pub fn type_coerce<A, B>(a: A) -> B {
-	try_type_coerce(a)
-		.unwrap_or_else(|| panic!("can't coerce {} to {}", type_name::<A>(), type_name::<B>()))
-}
-pub fn try_type_coerce<A, B>(a: A) -> Option<B> {
-	trait Eq<B> {
-		fn eq(self) -> Option<B>;
-	}
-
-	struct Foo<A, B>(A, PhantomData<fn() -> B>);
-
-	impl<A, B> Eq<B> for Foo<A, B> {
-		default fn eq(self) -> Option<B> {
-			None
-		}
-	}
-	impl<A> Eq<A> for Foo<A, A> {
-		fn eq(self) -> Option<A> {
-			Some(self.0)
-		}
-	}
-
-	Foo::<A, B>(a, PhantomData).eq()
-}
-
-#[repr(transparent)]
-pub struct Debug<T: ?Sized>(pub T);
-trait DebugDuck {
-	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error>;
-}
-impl<T: ?Sized> DebugDuck for T {
-	default fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		write!(f, "{}", std::any::type_name::<Self>())
-	}
-}
-impl<T: ?Sized> DebugDuck for T
-where
-	T: std::fmt::Debug,
-{
-	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		<T as std::fmt::Debug>::fmt(self, f)
-	}
-}
-impl<T: ?Sized> std::fmt::Debug for Debug<T> {
-	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-		<T as DebugDuck>::fmt(&self.0, f)
-	}
+/// As unsafe as regular `core::mem::transmute`, but asserts size at runtime.
+///
+/// # Safety
+///
+/// Not.
+#[allow(unsafe_code)]
+pub unsafe fn transmute<A, B>(a: A) -> B {
+	use std::mem;
+	assert_eq!(
+		(mem::size_of::<A>(), mem::align_of::<A>()),
+		(mem::size_of::<B>(), mem::align_of::<B>())
+	);
+	let ret = mem::transmute_copy(&a);
+	mem::forget(a);
+	ret
 }
diff --git a/amadeus-derive/Cargo.toml b/amadeus-derive/Cargo.toml
index cc3aea2e..03437613 100644
--- a/amadeus-derive/Cargo.toml
+++ b/amadeus-derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-derive"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
diff --git a/amadeus-derive/src/lib.rs b/amadeus-derive/src/lib.rs
index 8580b383..b365595d 100644
--- a/amadeus-derive/src/lib.rs
+++ b/amadeus-derive/src/lib.rs
@@ -1,25 +1,30 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#![doc(html_root_url = "https://docs.rs/amadeus-derive/0.2.5")]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. This macro is re-exposed as [`amadeus::data::Data`](https://docs.rs/amadeus/0.3/amadeus/data/derive.Data.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-derive/0.3.0")]
 #![recursion_limit = "400"]
-#![allow(clippy::useless_let_if_seq)]
-
-extern crate proc_macro;
+#![warn(
+	missing_copy_implementations,
+	missing_debug_implementations,
+	missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic
+)]
+#![allow(
+	clippy::doc_markdown,
+	clippy::too_many_lines,
+	clippy::useless_let_if_seq
+)]
+#![deny(unsafe_code)]
 
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
@@ -138,12 +143,13 @@ fn impl_struct(
 
 	let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
 
-	let where_clause = where_clause
-		.map(Clone::clone)
-		.unwrap_or_else(|| WhereClause {
+	let where_clause = where_clause.map_or_else(
+		|| WhereClause {
 			where_token: <Token![where]>::default(),
 			predicates: Punctuated::new(),
-		});
+		},
+		Clone::clone,
+	);
 	let mut where_clause_with_data = where_clause.clone();
 	for TypeParam { ident, .. } in ast.generics.type_params() {
 		where_clause_with_data
@@ -656,9 +662,9 @@ fn impl_struct(
 fn impl_tuple_struct(
 	ast: &DeriveInput, fields: &Punctuated<Field, Token![,]>,
 ) -> Result<TokenStream, Error> {
-	let _name = &ast.ident;
-	let _schema_name = Ident::new(&format!("{}Schema", _name), Span::call_site());
-	let _reader_name = Ident::new(&format!("{}Reader", _name), Span::call_site());
+	let name = &ast.ident;
+	let _schema_name = Ident::new(&format!("{}Schema", name), Span::call_site());
+	let _reader_name = Ident::new(&format!("{}Reader", name), Span::call_site());
 
 	let (_impl_generics, _ty_generics, _where_clause) = ast.generics.split_for_impl();
 
diff --git a/amadeus-parquet/Cargo.toml b/amadeus-parquet/Cargo.toml
index b0af1260..30bf1b68 100644
--- a/amadeus-parquet/Cargo.toml
+++ b/amadeus-parquet/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-parquet"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>", "Apache Arrow <dev@arrow.apache.org>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ An Apache Parquet implementation in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,8 +19,8 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
-amadeus-types = { version = "=0.2.5", path = "../amadeus-types" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
+amadeus-types = { version = "=0.3.0", path = "../amadeus-types" }
 async-trait = "0.1"
 brotli = "3.3"
 byteorder = "1.2"
diff --git a/amadeus-parquet/src/internal/file/reader.rs b/amadeus-parquet/src/internal/file/reader.rs
index 31238cf8..b136a30f 100644
--- a/amadeus-parquet/src/internal/file/reader.rs
+++ b/amadeus-parquet/src/internal/file/reader.rs
@@ -1223,7 +1223,7 @@ mod tests {
 				let mut def_levels = Some(vec![0; batch_size]);
 				let mut rep_levels = None::<Vec<i16>>;
 
-				for col_reader in readers.into_iter() {
+				for col_reader in readers {
 					match col_reader {
 						r @ ColumnReader::Int64ColumnReader(..) => {
 							let mut data_collected = Vec::with_capacity(num_rows);
diff --git a/amadeus-parquet/src/internal/mod.rs b/amadeus-parquet/src/internal/mod.rs
index bc7f35f9..237d23e7 100644
--- a/amadeus-parquet/src/internal/mod.rs
+++ b/amadeus-parquet/src/internal/mod.rs
@@ -1,45 +1,3 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-//! An Apache Parquet implementation in Rust.
-//!
-//! **[Crates.io](https://crates.io/crates/amadeus-parquet) │ [Repo](https://github.com/constellation-rs/amadeus)**
-
-// #![doc(html_root_url = "https://docs.rs/amadeus-parquet/0.1.0")]
-// #![feature(
-// 	specialization,
-// 	type_alias_impl_trait,
-// 	bufreader_seek_relative,
-// 	read_initializer
-// )]
-#![warn(
-// missing_copy_implementations,
-// missing_debug_implementations,
-// missing_docs,
-// trivial_casts,
-// trivial_numeric_casts,
-	unused_import_braces,
-	unused_qualifications,
-	unused_results,
-// clippy::pedantic
-)]
-// from https://github.com/rust-unofficial/patterns/blob/master/anti_patterns/deny-warnings.md
-#![allow(dead_code, clippy::all)]
-
 #[macro_use]
 pub mod errors;
 pub mod basic;
diff --git a/amadeus-parquet/src/internal/record/impls.rs b/amadeus-parquet/src/internal/record/impls.rs
index 03801892..c2d74b27 100644
--- a/amadeus-parquet/src/internal/record/impls.rs
+++ b/amadeus-parquet/src/internal/record/impls.rs
@@ -1,10 +1,9 @@
 use linked_hash_map::LinkedHashMap;
 use std::{
-	collections::HashMap, convert::{TryFrom, TryInto}, fmt, hash::{BuildHasher, Hash}, marker::PhantomData, string::FromUtf8Error, sync::Arc
+	any::type_name, collections::HashMap, convert::{TryFrom, TryInto}, fmt, hash::{BuildHasher, Hash}, marker::PhantomData, string::FromUtf8Error, sync::Arc
 };
 use sum::{Sum2, Sum3};
 
-use amadeus_core::util::type_coerce;
 use amadeus_types::{
 	Bson, Data, Date, DateTime, DateTimeWithoutTimezone, DateWithoutTimezone, Decimal, Enum, Group, IpAddr, Json, List, Time, TimeWithoutTimezone, Timezone, Url, Value, Webpage
 };
@@ -2096,3 +2095,30 @@ impl From<amadeus_types::ParseWebpageError> for ParquetError {
 		ParquetError::General(err.to_string())
 	}
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+fn type_coerce<A, B>(a: A) -> B {
+	try_type_coerce(a)
+		.unwrap_or_else(|| panic!("can't coerce {} to {}", type_name::<A>(), type_name::<B>()))
+}
+fn try_type_coerce<A, B>(a: A) -> Option<B> {
+	trait Eq<B> {
+		fn eq(self) -> Option<B>;
+	}
+
+	struct Foo<A, B>(A, PhantomData<fn() -> B>);
+
+	impl<A, B> Eq<B> for Foo<A, B> {
+		default fn eq(self) -> Option<B> {
+			None
+		}
+	}
+	impl<A> Eq<A> for Foo<A, A> {
+		fn eq(self) -> Option<A> {
+			Some(self.0)
+		}
+	}
+
+	Foo::<A, B>(a, PhantomData).eq()
+}
diff --git a/amadeus-parquet/src/internal/record/reader.rs b/amadeus-parquet/src/internal/record/reader.rs
index 9615c915..38cbf35d 100644
--- a/amadeus-parquet/src/internal/record/reader.rs
+++ b/amadeus-parquet/src/internal/record/reader.rs
@@ -439,7 +439,7 @@ impl Reader for ValueReader {
 			}
 			ValueReader::ByteArray(ref mut reader) => reader
 				.read(def_level, rep_level)
-				.map(|vec| Value::List(vec.into_iter().map(Value::from).collect())),
+				.map(|vec| Value::List(vec.map(Value::from))),
 			ValueReader::Bson(ref mut reader) => reader.read(def_level, rep_level).map(Value::Bson),
 			ValueReader::String(ref mut reader) => {
 				reader.read(def_level, rep_level).map(Value::String)
diff --git a/amadeus-parquet/src/lib.rs b/amadeus-parquet/src/lib.rs
index cc34331b..229eef94 100644
--- a/amadeus-parquet/src/lib.rs
+++ b/amadeus-parquet/src/lib.rs
@@ -1,10 +1,40 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-parquet/0.2.5")]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::source`](https://docs.rs/amadeus/0.3/amadeus/source/index.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-parquet/0.3.0")]
 #![feature(bufreader_seek_relative)]
 #![feature(read_initializer)]
 #![feature(specialization)]
 #![feature(type_alias_impl_trait)]
 #![cfg_attr(test, feature(test))]
-#![allow(incomplete_features)]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	// trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	// unreachable_pub,
+	// clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::similar_names,
+	clippy::if_not_else,
+	clippy::must_use_candidate,
+	clippy::missing_errors_doc,
+	dead_code,
+	clippy::all,
+	incomplete_features
+)]
+// #![deny(unsafe_code)]
+
 #[cfg(test)]
 extern crate test;
 
diff --git a/amadeus-postgres/Cargo.toml b/amadeus-postgres/Cargo.toml
index ce7993b9..9ec510a1 100644
--- a/amadeus-postgres/Cargo.toml
+++ b/amadeus-postgres/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-postgres"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,8 +19,8 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
-amadeus-types = { version = "=0.2.5", path = "../amadeus-types" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
+amadeus-types = { version = "=0.3.0", path = "../amadeus-types" }
 bytes = "0.5"
 chrono = { version = "0.4", default-features = false }
 educe = "0.4"
diff --git a/amadeus-postgres/src/impls.rs b/amadeus-postgres/src/impls.rs
index 0a243e9f..ec2e8875 100644
--- a/amadeus-postgres/src/impls.rs
+++ b/amadeus-postgres/src/impls.rs
@@ -18,7 +18,7 @@ where
 	}
 	default fn decode(
 		type_: &::postgres::types::Type, buf: Option<&[u8]>,
-	) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+	) -> Result<Self, Box<dyn Error + Sync + Send>> {
 		T::decode(type_, buf).map(Box::new)
 	}
 }
diff --git a/amadeus-postgres/src/lib.rs b/amadeus-postgres/src/lib.rs
index 4b656b0d..cce5670c 100644
--- a/amadeus-postgres/src/lib.rs
+++ b/amadeus-postgres/src/lib.rs
@@ -1,13 +1,40 @@
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::source`](https://docs.rs/amadeus/0.3/amadeus/source/index.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-postgres/0.3.0")]
+#![feature(specialization)]
+#![feature(type_alias_impl_trait)]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::similar_names,
+	clippy::if_not_else,
+	clippy::must_use_candidate,
+	clippy::missing_errors_doc,
+	incomplete_features
+)]
+#![deny(unsafe_code)]
+
 // TODO:
 // Check types? These might work??
 // select column_name, is_nullable, data_type, character_maximum_length, * from information_schema.columns where table_name = 'weather' order by ordinal_position;
 // select attname, atttypid, atttypmod, attnotnull, attndims from pg_attribute where attrelid = 'public.weather'::regclass and attnum > 0 and not attisdropped;
 
-#![doc(html_root_url = "https://docs.rs/amadeus-postgres/0.2.5")]
-#![feature(specialization)]
-#![feature(type_alias_impl_trait)]
-#![allow(incomplete_features)]
-
 mod impls;
 
 #[doc(hidden)]
@@ -19,7 +46,7 @@ use futures::{ready, stream, FutureExt, Stream, StreamExt, TryStreamExt};
 use pin_project::pin_project;
 use postgres::{CopyOutStream, Error as InternalPostgresError};
 use serde::{Deserialize, Serialize};
-use serde_closure::*;
+use serde_closure::FnMut;
 use std::{
 	convert::TryFrom, error, fmt::{self, Debug, Display}, io, io::Cursor, marker::PhantomData, ops::Fn, path::PathBuf, pin::Pin, str, sync::Arc, task::{Context, Poll}, time::Duration
 };
@@ -219,7 +246,7 @@ where
 					.connect(postgres::tls::NoTls)
 					.await
 					.expect("Error handling not yet implemented. Tracking at https://github.com/constellation-rs/amadeus/issues/63");
-				tokio::spawn(async move {
+				let _ = tokio::spawn(async move {
 					let _ = connection.await;
 				});
 				let client = Arc::new(client);
@@ -241,7 +268,7 @@ where
 							.map_ok(|row| {
 								Row::decode(
 									&postgres::types::Type::RECORD,
-									row.as_ref().map(|bytes| bytes.as_ref()),
+									row.as_ref().map(AsRef::as_ref),
 								)
 								.expect("Error handling not yet implemented. Tracking at https://github.com/constellation-rs/amadeus/issues/63")
 							})
@@ -317,22 +344,24 @@ impl Stream for BinaryCopyOutStream {
 		}
 
 		check_remaining(&chunk, 2)?;
-		let len = chunk.get_i16();
-		if len == -1 {
+		let row_len = chunk.get_i16();
+		if row_len == -1 {
 			return Poll::Ready(None);
 		}
 
-		assert_eq!(len, 1);
+		assert_eq!(row_len, 1);
 
 		check_remaining(&chunk, 4)?;
-		let len = chunk.get_i32();
-		if len == -1 {
+		let field_len = chunk.get_i32();
+		if field_len == -1 {
 			Poll::Ready(Some(Ok(None)))
 		} else {
-			let len = len as usize;
-			check_remaining(&chunk, len)?;
-			let start = chunk.position() as usize;
-			Poll::Ready(Some(Ok(Some(chunk.into_inner().slice(start..start + len)))))
+			let field_len = usize::try_from(field_len).unwrap();
+			check_remaining(&chunk, field_len)?;
+			let start = usize::try_from(chunk.position()).unwrap();
+			Poll::Ready(Some(Ok(Some(
+				chunk.into_inner().slice(start..start + field_len),
+			))))
 		}
 	}
 }
@@ -444,7 +473,7 @@ impl<F> DisplayFmt<F>
 where
 	F: Fn(&mut fmt::Formatter) -> fmt::Result,
 {
-	pub fn new(f: F) -> Self {
+	fn new(f: F) -> Self {
 		Self(f)
 	}
 }
diff --git a/amadeus-serde/Cargo.toml b/amadeus-serde/Cargo.toml
index b8df63e4..b8f124fc 100644
--- a/amadeus-serde/Cargo.toml
+++ b/amadeus-serde/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-serde"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "parser-implementations", "text-processing"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,8 +19,8 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
-amadeus-types = { version = "=0.2.5", path = "../amadeus-types" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
+amadeus-types = { version = "=0.3.0", path = "../amadeus-types" }
 chrono = { version = "0.4", default-features = false, features = ["serde"] }
 csv = "1.0"
 educe = "0.4"
@@ -31,3 +31,4 @@ serde_bytes = "0.11"
 serde_closure = "0.2"
 serde_json = "1.0"
 sum = { version = "0.1", features = ["serde"] }
+vec-utils = "0.2"
diff --git a/amadeus-serde/src/csv.rs b/amadeus-serde/src/csv.rs
index 0599281e..bd2a0a9c 100644
--- a/amadeus-serde/src/csv.rs
+++ b/amadeus-serde/src/csv.rs
@@ -2,7 +2,7 @@ use csv::Error as InternalCsvError;
 use educe::Educe;
 use futures::{pin_mut, stream, AsyncReadExt, FutureExt, StreamExt};
 use serde::{Deserialize, Serialize};
-use serde_closure::*;
+use serde_closure::FnMut;
 use std::{
 	error, fmt::{self, Display}, io::Cursor, marker::PhantomData
 };
@@ -152,13 +152,13 @@ where
 mod csverror {
 	use serde::{Deserializer, Serializer};
 
-	pub fn serialize<T, S>(_t: &T, _serializer: S) -> Result<S::Ok, S::Error>
+	pub(crate) fn serialize<T, S>(_t: &T, _serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: Serializer,
 	{
 		unimplemented!()
 	}
-	pub fn deserialize<'de, T, D>(_deserializer: D) -> Result<T, D::Error>
+	pub(crate) fn deserialize<'de, T, D>(_deserializer: D) -> Result<T, D::Error>
 	where
 		D: Deserializer<'de>,
 	{
diff --git a/amadeus-serde/src/impls.rs b/amadeus-serde/src/impls.rs
index e9efb150..b88fc087 100644
--- a/amadeus-serde/src/impls.rs
+++ b/amadeus-serde/src/impls.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::too_many_lines)]
+
 use linked_hash_map::LinkedHashMap;
 use serde::{
 	de::{self, MapAccess, SeqAccess, Visitor}, ser::{SerializeSeq, SerializeStruct, SerializeTupleStruct}, Deserializer, Serializer
@@ -5,6 +7,7 @@ use serde::{
 use std::{
 	collections::HashMap, fmt, hash::{BuildHasher, Hash}, str, sync::Arc
 };
+use vec_utils::VecExt;
 
 use amadeus_types::{
 	Bson, Data, Date, DateTime, DateTimeWithoutTimezone, DateWithoutTimezone, Decimal, Enum, Group, IpAddr, Json, List, SchemaIncomplete, Time, TimeWithoutTimezone, Timezone, Url, Value, ValueRequired, Webpage
@@ -171,7 +174,7 @@ where
 		S: Serializer,
 	{
 		let mut serializer = serializer.serialize_seq(Some(self.len()))?;
-		for item in self.clone().into_iter() {
+		for item in self.clone() {
 			serializer.serialize_element(&SerdeSerialize(&item))?;
 		}
 		serializer.end()
@@ -478,6 +481,7 @@ macro_rules! array {
 				S: Serializer,
 			{
 				let self_: *const Self = self;
+				#[allow(unsafe_code)]
 				let self_: &[SerdeSerialize<T>; $i] = unsafe{ &*(self_ as *const _)};
 				serde::Serialize::serialize(self_, serializer)
 			}
@@ -488,7 +492,7 @@ macro_rules! array {
 				D: Deserializer<'de>,
 			{
 				let self_: [SerdeDeserialize<T>; $i] = serde::Deserialize::deserialize(deserializer)?;
-				let self_: Box<Self> = std::array::IntoIter::new(self_).map(|a|a.0).collect::<Vec<T>>().into_boxed_slice().try_into().unwrap();
+				let self_: Box<Self> = <Vec<SerdeDeserialize<T>>>::from(self_).map(|a|a.0).into_boxed_slice().try_into().unwrap();
 				Ok(*self_)
 			}
 		}
@@ -529,6 +533,7 @@ macro_rules! array {
 				D: Deserializer<'de>,
 			{
 				let self_: Box<[SerdeDeserialize<T>; $i]> = serde::Deserialize::deserialize(deserializer)?;
+				#[allow(unsafe_code)]
 				Ok(unsafe { Box::from_raw(Box::into_raw(self_) as *mut [T; $i]) })
 			}
 		}
diff --git a/amadeus-serde/src/json.rs b/amadeus-serde/src/json.rs
index bec8c36f..c67afd07 100644
--- a/amadeus-serde/src/json.rs
+++ b/amadeus-serde/src/json.rs
@@ -1,7 +1,7 @@
 use educe::Educe;
 use futures::{pin_mut, stream, AsyncReadExt, FutureExt, StreamExt};
 use serde::{Deserialize, Serialize};
-use serde_closure::*;
+use serde_closure::FnMut;
 use serde_json::Error as InternalJsonError;
 use std::{
 	error, fmt::{self, Debug, Display}, io::{self, Cursor}, marker::PhantomData
@@ -106,13 +106,13 @@ where
 mod jsonerror {
 	use serde::{Deserializer, Serializer};
 
-	pub fn serialize<T, S>(_t: &T, _serializer: S) -> Result<S::Ok, S::Error>
+	pub(crate) fn serialize<T, S>(_t: &T, _serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: Serializer,
 	{
 		unimplemented!()
 	}
-	pub fn deserialize<'de, T, D>(_deserializer: D) -> Result<T, D::Error>
+	pub(crate) fn deserialize<'de, T, D>(_deserializer: D) -> Result<T, D::Error>
 	where
 		D: Deserializer<'de>,
 	{
diff --git a/amadeus-serde/src/lib.rs b/amadeus-serde/src/lib.rs
index 2c2bf3ba..59a9cfeb 100644
--- a/amadeus-serde/src/lib.rs
+++ b/amadeus-serde/src/lib.rs
@@ -1,8 +1,36 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-serde/0.2.5")]
-#![feature(array_value_iter)]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::source`](https://docs.rs/amadeus/0.3/amadeus/source/index.html).
+
+#![doc(html_root_url = "https://docs.rs/amadeus-serde/0.3.0")]
 #![feature(specialization)]
 #![feature(type_alias_impl_trait)]
-#![allow(incomplete_features)]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::similar_names,
+	clippy::if_not_else,
+	clippy::must_use_candidate,
+	clippy::missing_errors_doc,
+	clippy::needless_pass_by_value,
+	clippy::default_trait_access,
+	incomplete_features
+)]
+#![deny(unsafe_code)]
 
 mod csv;
 mod impls;
diff --git a/amadeus-types/Cargo.toml b/amadeus-types/Cargo.toml
index bf5332c6..5b4e53f5 100644
--- a/amadeus-types/Cargo.toml
+++ b/amadeus-types/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "amadeus-types"
-version = "0.2.5"
+version = "0.3.0"
 license = "Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["concurrency", "science", "database", "date-and-time", "data-structures"]
@@ -10,7 +10,7 @@ Harmonious distributed data analysis in Rust.
 """
 repository = "https://github.com/alecmocatta/amadeus"
 homepage = "https://github.com/alecmocatta/amadeus"
-documentation = "https://docs.rs/amadeus/0.2.5"
+documentation = "https://docs.rs/amadeus/0.3.0"
 readme = "README.md"
 edition = "2018"
 
@@ -19,7 +19,7 @@ azure-devops = { project = "alecmocatta/amadeus", pipeline = "tests" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-amadeus-core = { version = "=0.2.5", path = "../amadeus-core" }
+amadeus-core = { version = "=0.3.0", path = "../amadeus-core" }
 chrono = { version = "0.4", default-features = false, features = ["std", "serde"] }
 chrono-tz = { version = "0.5", features = ["serde"] }
 fxhash = "0.2"
@@ -28,3 +28,4 @@ once_cell = "1.0"
 ordered-float = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 url = { version = "2.1", features = ["serde"] }
+vec-utils = "0.2"
diff --git a/amadeus-types/src/data.rs b/amadeus-types/src/data.rs
index 7be5cc8c..f7a71c08 100644
--- a/amadeus-types/src/data.rs
+++ b/amadeus-types/src/data.rs
@@ -8,7 +8,7 @@ use super::*;
 
 // + AmadeusOrd + DowncastFrom<Value> + Into<Value>
 pub trait Data: Clone + Debug + Send + Sized + 'static {
-	type Vec: list::ListVec<Self>;
+	type Vec: ListVec<Self>;
 	type DynamicType;
 	fn new_vec(_type: Self::DynamicType) -> Self::Vec;
 }
diff --git a/amadeus-types/src/group.rs b/amadeus-types/src/group.rs
index 25484a6c..158c9dca 100644
--- a/amadeus-types/src/group.rs
+++ b/amadeus-types/src/group.rs
@@ -7,7 +7,7 @@ use std::{
 	cmp::Ordering, fmt::{self, Debug}, ops::Index, slice::SliceIndex, str, sync::Arc
 };
 
-use super::{AmadeusOrd, Downcast, DowncastError, DowncastFrom, Value};
+use super::{util::IteratorExt, AmadeusOrd, Downcast, DowncastError, DowncastFrom, Value};
 
 /// Corresponds to Parquet groups of named fields.
 ///
@@ -74,7 +74,7 @@ impl<'de> Deserialize<'de> for Group {
 // impl From<Group> for internal::record::types::Group {
 // 	fn from(group: Group) -> Self {
 // 		let field_names = group.field_names();
-// 		Self::new(group.into_fields().into_iter().map(Into::into).collect(), field_names)
+// 		Self::new(group.into_fields().map(Into::into), field_names)
 // 	}
 // }
 impl<I> Index<I> for Group
@@ -106,14 +106,14 @@ impl AmadeusOrd for Group {
 				.iter()
 				.map(|(name, _index)| name)
 				.zip(&self.fields)
-				.cmp_by(
+				.cmp_by_(
 					b.iter().map(|(name, _index)| name).zip(&other.fields),
 					|a, b| a.amadeus_cmp(&b),
 				),
 			(None, None) => self
 				.fields
 				.iter()
-				.cmp_by(&other.fields, AmadeusOrd::amadeus_cmp),
+				.cmp_by_(&other.fields, AmadeusOrd::amadeus_cmp),
 			(Some(_), None) => Ordering::Less,
 			(None, Some(_)) => Ordering::Greater,
 		}
diff --git a/amadeus-types/src/lib.rs b/amadeus-types/src/lib.rs
index 47a0c27a..a46955ac 100644
--- a/amadeus-types/src/lib.rs
+++ b/amadeus-types/src/lib.rs
@@ -1,9 +1,36 @@
-#![doc(html_root_url = "https://docs.rs/amadeus-types/0.2.5")]
-#![feature(iter_order_by)]
-#![feature(min_specialization)]
+//! Harmonious distributed data processing & analysis in Rust.
+//!
+//! <p style="font-family: 'Fira Sans',sans-serif;padding:0.3em 0"><strong>
+//! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
+//! </strong></p>
+//!
+//! This is a support crate of [Amadeus](https://github.com/constellation-rs/amadeus) and is not intended to be used directly. These types are re-exposed in [`amadeus::data`](https://docs.rs/amadeus/0.3/amadeus/data/index.html).
 
-//! Implementations of Rust types that correspond to Parquet logical types.
-//! [`Record`](super::Record) is implemented for each of them.
+#![doc(html_root_url = "https://docs.rs/amadeus-types/0.3.0")]
+#![warn(
+	// missing_copy_implementations,
+	// missing_debug_implementations,
+	// missing_docs,
+	trivial_numeric_casts,
+	unused_import_braces,
+	unused_qualifications,
+	unused_results,
+	// unreachable_pub,
+	clippy::pedantic,
+)]
+#![allow(
+	clippy::module_name_repetitions,
+	clippy::similar_names,
+	clippy::if_not_else,
+	clippy::must_use_candidate,
+	clippy::missing_errors_doc,
+	clippy::doc_markdown,
+	clippy::wildcard_imports,
+	clippy::default_trait_access,
+	clippy::inline_always,
+	clippy::too_many_lines
+)]
+#![deny(unsafe_code)]
 
 #[macro_export]
 macro_rules! array {
@@ -58,6 +85,7 @@ mod http;
 mod list;
 mod ord;
 mod time;
+mod util;
 mod value;
 mod value_required;
 
diff --git a/amadeus-types/src/list.rs b/amadeus-types/src/list.rs
index 79d39e70..9d358ef6 100644
--- a/amadeus-types/src/list.rs
+++ b/amadeus-types/src/list.rs
@@ -5,11 +5,9 @@ use std::{
 	cmp::Ordering, fmt::{self, Debug}, hash::{Hash, Hasher}, iter::FromIterator, mem::ManuallyDrop, ops::{Deref, DerefMut}, panic::{RefUnwindSafe, UnwindSafe}
 };
 
-use super::{AmadeusOrd, Data};
+use super::{util::IteratorExt, AmadeusOrd, Data};
 use amadeus_core::{
-	par_sink::{
-		DefaultReducerFactory, ExtendReducer, FromDistributedStream, FromParallelStream, PushReducer
-	}, pool::ProcessSend, util::type_coerce
+	par_sink::{ExtendReducer, FromDistributedStream, FromParallelStream, PushReducer}, pool::ProcessSend
 };
 
 pub struct List<T: Data> {
@@ -51,6 +49,22 @@ impl<T: Data> List<T> {
 	// pub fn iter(&self) -> <&Self as IntoIterator>::IntoIter {
 	// 	self.into_iter()
 	// }
+	#[inline(always)]
+	pub fn map<F, U: Data>(self, f: F) -> List<U>
+	where
+		F: FnMut(T) -> U,
+	{
+		// TODO
+		self.into_iter().map(f).collect()
+	}
+	#[inline(always)]
+	pub fn try_map<F, U: Data, E>(self, f: F) -> Result<List<U>, E>
+	where
+		F: FnMut(T) -> Result<U, E>,
+	{
+		// TODO
+		self.into_iter().map(f).collect()
+	}
 }
 impl<T: Data> Default for List<T> {
 	#[inline(always)]
@@ -128,7 +142,7 @@ where
 	fn eq(&self, other: &List<U>) -> bool {
 		self.clone()
 			.into_iter()
-			.eq_by(other.clone().into_iter(), |a, b| a.eq(&b))
+			.eq_by_(other.clone().into_iter(), |a, b| a.eq(&b))
 	}
 }
 impl<T: Data> Eq for List<T> where T: Eq {}
@@ -140,7 +154,7 @@ where
 	fn partial_cmp(&self, other: &List<U>) -> Option<Ordering> {
 		self.clone()
 			.into_iter()
-			.partial_cmp_by(other.clone().into_iter(), |a, b| a.partial_cmp(&b))
+			.partial_cmp_by_(other.clone().into_iter(), |a, b| a.partial_cmp(&b))
 	}
 }
 impl<T: Data> Ord for List<T>
@@ -151,7 +165,7 @@ where
 	fn cmp(&self, other: &Self) -> Ordering {
 		self.clone()
 			.into_iter()
-			.cmp_by(other.clone().into_iter(), |a, b| a.cmp(&b))
+			.cmp_by_(other.clone().into_iter(), |a, b| a.cmp(&b))
 	}
 }
 impl<T: Data> AmadeusOrd for List<T>
@@ -162,7 +176,7 @@ where
 	fn amadeus_cmp(&self, other: &Self) -> Ordering {
 		self.clone()
 			.into_iter()
-			.cmp_by(other.clone().into_iter(), |a, b| a.amadeus_cmp(&b))
+			.cmp_by_(other.clone().into_iter(), |a, b| a.amadeus_cmp(&b))
 	}
 }
 impl<T: Data> Hash for List<T>
@@ -213,7 +227,9 @@ impl<T: Data> UnwindSafe for List<T> where T: UnwindSafe {}
 impl<T: Data> RefUnwindSafe for List<T> where T: RefUnwindSafe {}
 impl<T: Data> Unpin for List<T> where T: Unpin {}
 // Implementers of ListVec must be Send/Sync if T is Send/Sync!
+#[allow(unsafe_code)]
 unsafe impl<T: Data> Send for List<T> where T: Send {}
+#[allow(unsafe_code)]
 unsafe impl<T: Data> Sync for List<T> where T: Sync {}
 
 impl Deref for List<u8> {
@@ -221,13 +237,13 @@ impl Deref for List<u8> {
 
 	#[inline(always)]
 	fn deref(&self) -> &Self::Target {
-		&*type_coerce::<_, &Vec<u8>>(&self.vec)
+		&*self.vec
 	}
 }
 impl DerefMut for List<u8> {
 	#[inline(always)]
 	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut *type_coerce::<_, &mut Vec<u8>>(&mut self.vec)
+		&mut *self.vec
 	}
 }
 
@@ -370,11 +386,10 @@ impl<T: Data> FromParallelStream<T> for List<T>
 where
 	T: Send + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -383,13 +398,11 @@ impl<T: Data> FromDistributedStream<T> for List<T>
 where
 	T: ProcessSend + 'static,
 {
-	type ReduceAFactory = DefaultReducerFactory<Self::ReduceA>;
-	type ReduceBFactory = DefaultReducerFactory<Self::ReduceB>;
 	type ReduceA = PushReducer<T, Self>;
 	type ReduceB = ExtendReducer<Self>;
 	type ReduceC = ExtendReducer<Self>;
 
-	fn reducers() -> (Self::ReduceAFactory, Self::ReduceBFactory, Self::ReduceC) {
+	fn reducers() -> (Self::ReduceA, Self::ReduceB, Self::ReduceC) {
 		Default::default()
 	}
 }
@@ -402,8 +415,8 @@ mod test {
 	#[test]
 	fn test() {
 		let mut list: List<u8> = List::new();
-		list.push(0u8);
-		list.push(1u8);
+		list.push(0_u8);
+		list.push(1_u8);
 		println!("{:#?}", list);
 		let mut list: List<Value> = List::new();
 		list.push(Value::U8(0));
diff --git a/amadeus-types/src/time.rs b/amadeus-types/src/time.rs
index 2695419a..b3411f4b 100644
--- a/amadeus-types/src/time.rs
+++ b/amadeus-types/src/time.rs
@@ -174,11 +174,11 @@ impl Timezone {
 				-7200 => Some(Etc::GMTPlus2),
 				-10800 => Some(Etc::GMTPlus3),
 				-14400 => Some(Etc::GMTPlus4),
-				-18000 => Some(Etc::GMTPlus4),
-				-21600 => Some(Etc::GMTPlus5),
-				-25200 => Some(Etc::GMTPlus6),
-				-28800 => Some(Etc::GMTPlus7),
-				-32400 => Some(Etc::GMTPlus8),
+				-18000 => Some(Etc::GMTPlus5),
+				-21600 => Some(Etc::GMTPlus6),
+				-25200 => Some(Etc::GMTPlus7),
+				-28800 => Some(Etc::GMTPlus8),
+				-32400 => Some(Etc::GMTPlus9),
 				-36000 => Some(Etc::GMTPlus10),
 				-39600 => Some(Etc::GMTPlus11),
 				-43200 => Some(Etc::GMTPlus12),
diff --git a/amadeus-types/src/util.rs b/amadeus-types/src/util.rs
new file mode 100644
index 00000000..3ae2d59c
--- /dev/null
+++ b/amadeus-types/src/util.rs
@@ -0,0 +1,94 @@
+// from https://github.com/rust-lang/rust/blob/0cd7ff7ddfb75a38dca81ad3e76b1e984129e939/src/libcore/iter/traits/iterator.rs
+
+use std::cmp::Ordering;
+
+pub(crate) trait IteratorExt: Iterator {
+	fn cmp_by_<I, F>(mut self, other: I, mut cmp: F) -> Ordering
+	where
+		Self: Sized,
+		I: IntoIterator,
+		F: FnMut(Self::Item, I::Item) -> Ordering,
+	{
+		let mut other = other.into_iter();
+
+		loop {
+			let x = match self.next() {
+				None => {
+					if other.next().is_none() {
+						return Ordering::Equal;
+					} else {
+						return Ordering::Less;
+					}
+				}
+				Some(val) => val,
+			};
+
+			let y = match other.next() {
+				None => return Ordering::Greater,
+				Some(val) => val,
+			};
+
+			match cmp(x, y) {
+				Ordering::Equal => (),
+				non_eq => return non_eq,
+			}
+		}
+	}
+	fn partial_cmp_by_<I, F>(mut self, other: I, mut partial_cmp: F) -> Option<Ordering>
+	where
+		Self: Sized,
+		I: IntoIterator,
+		F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
+	{
+		let mut other = other.into_iter();
+
+		loop {
+			let x = match self.next() {
+				None => {
+					if other.next().is_none() {
+						return Some(Ordering::Equal);
+					} else {
+						return Some(Ordering::Less);
+					}
+				}
+				Some(val) => val,
+			};
+
+			let y = match other.next() {
+				None => return Some(Ordering::Greater),
+				Some(val) => val,
+			};
+
+			match partial_cmp(x, y) {
+				Some(Ordering::Equal) => (),
+				non_eq => return non_eq,
+			}
+		}
+	}
+	fn eq_by_<I, F>(mut self, other: I, mut eq: F) -> bool
+	where
+		Self: Sized,
+		I: IntoIterator,
+		F: FnMut(Self::Item, I::Item) -> bool,
+	{
+		let mut other = other.into_iter();
+
+		loop {
+			let x = match self.next() {
+				None => return other.next().is_none(),
+				Some(val) => val,
+			};
+
+			let y = match other.next() {
+				None => return false,
+				Some(val) => val,
+			};
+
+			if !eq(x, y) {
+				return false;
+			}
+		}
+	}
+}
+
+impl<I: ?Sized> IteratorExt for I where I: Iterator {}
diff --git a/amadeus-types/src/value.rs b/amadeus-types/src/value.rs
index 3ed694f2..d5912d52 100644
--- a/amadeus-types/src/value.rs
+++ b/amadeus-types/src/value.rs
@@ -8,6 +8,7 @@ use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
 use std::{
 	cmp::Ordering, collections::HashMap, convert::TryInto, fmt, fmt::Debug, hash::{BuildHasher, Hash, Hasher}, iter::FromIterator, sync::Arc
 };
+use vec_utils::VecExt;
 
 use crate::list::ListVec;
 
@@ -211,118 +212,118 @@ impl Hash for Value {
 	fn hash<H: Hasher>(&self, state: &mut H) {
 		match self {
 			Self::Bool(value) => {
-				0u8.hash(state);
+				0_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U8(value) => {
-				1u8.hash(state);
+				1_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I8(value) => {
-				2u8.hash(state);
+				2_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U16(value) => {
-				3u8.hash(state);
+				3_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I16(value) => {
-				4u8.hash(state);
+				4_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U32(value) => {
-				5u8.hash(state);
+				5_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I32(value) => {
-				6u8.hash(state);
+				6_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U64(value) => {
-				7u8.hash(state);
+				7_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I64(value) => {
-				8u8.hash(state);
+				8_u8.hash(state);
 				value.hash(state);
 			}
 			Self::F32(_value) => {
-				9u8.hash(state);
+				9_u8.hash(state);
 			}
 			Self::F64(_value) => {
-				10u8.hash(state);
+				10_u8.hash(state);
 			}
 			Self::Date(value) => {
-				11u8.hash(state);
+				11_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateWithoutTimezone(value) => {
-				11u8.hash(state);
+				11_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Time(value) => {
-				12u8.hash(state);
+				12_u8.hash(state);
 				value.hash(state);
 			}
 			Self::TimeWithoutTimezone(value) => {
-				12u8.hash(state);
+				12_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateTime(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateTimeWithoutTimezone(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Timezone(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Decimal(_value) => {
-				14u8.hash(state);
+				14_u8.hash(state);
 			}
 			Self::Bson(value) => {
-				15u8.hash(state);
+				15_u8.hash(state);
 				value.hash(state);
 			}
 			Self::String(value) => {
-				16u8.hash(state);
+				16_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Json(value) => {
-				17u8.hash(state);
+				17_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Enum(value) => {
-				18u8.hash(state);
+				18_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Url(value) => {
-				19u8.hash(state);
+				19_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Webpage(value) => {
-				20u8.hash(state);
+				20_u8.hash(state);
 				value.hash(state);
 			}
 			Self::IpAddr(value) => {
-				21u8.hash(state);
+				21_u8.hash(state);
 				value.hash(state);
 			}
 			Self::List(value) => {
-				22u8.hash(state);
+				22_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Map(_value) => {
-				23u8.hash(state);
+				23_u8.hash(state);
 			}
 			Self::Group(_value) => {
-				24u8.hash(state);
+				24_u8.hash(state);
 			}
 			Self::Option(value) => {
-				25u8.hash(state);
+				25_u8.hash(state);
 				value.hash(state);
 			}
 		}
@@ -1569,14 +1570,8 @@ impl<T: Data> From<List<T>> for Value
 where
 	T: Into<Self>,
 {
-	default fn from(value: List<T>) -> Self {
-		Self::List(value.into_iter().map(Into::into).collect::<List<_>>())
-	}
-}
-#[doc(hidden)]
-impl From<List<Self>> for Value {
-	fn from(value: List<Self>) -> Self {
-		Self::List(value)
+	fn from(value: List<T>) -> Self {
+		Self::List(value.map(Into::into))
 	}
 }
 impl<K, V, S> From<HashMap<K, V, S>> for Value
@@ -1585,7 +1580,7 @@ where
 	V: Into<Self>,
 	S: BuildHasher,
 {
-	default fn from(value: HashMap<K, V, S>) -> Self {
+	fn from(value: HashMap<K, V, S>) -> Self {
 		Self::Map(
 			value
 				.into_iter()
@@ -1594,12 +1589,6 @@ where
 		)
 	}
 }
-#[doc(hidden)]
-impl From<HashMap<Self, Self>> for Value {
-	fn from(value: HashMap<Self, Self>) -> Self {
-		Self::Map(value)
-	}
-}
 impl From<Group> for Value {
 	fn from(value: Group) -> Self {
 		Self::Group(value)
@@ -1609,7 +1598,7 @@ impl<T> From<Option<T>> for Value
 where
 	T: Into<Self>,
 {
-	default fn from(value: Option<T>) -> Self {
+	fn from(value: Option<T>) -> Self {
 		Self::Option(
 			value
 				.map(Into::into)
@@ -1617,12 +1606,6 @@ where
 		)
 	}
 }
-#[doc(hidden)]
-impl From<Option<Self>> for Value {
-	fn from(value: Option<Self>) -> Self {
-		Self::Option(value.map(|x| <Option<ValueRequired>>::from(x).unwrap()))
-	}
-}
 impl<T> From<Box<T>> for Value
 where
 	T: Into<Self>,
@@ -1800,18 +1783,10 @@ impl<T: Data> DowncastFrom<Value> for List<T>
 where
 	T: DowncastFrom<Value>,
 {
-	default fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
-		self_.into_list().and_then(|list| {
-			list.into_iter()
-				.map(Downcast::downcast)
-				.collect::<Result<List<_>, _>>()
-		})
-	}
-}
-#[doc(hidden)]
-impl DowncastFrom<Value> for List<Value> {
 	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
-		self_.into_list()
+		self_
+			.into_list()
+			.and_then(|list| list.try_map(Downcast::downcast))
 	}
 }
 impl<K, V, S> DowncastFrom<Value> for HashMap<K, V, S>
@@ -1820,7 +1795,7 @@ where
 	V: DowncastFrom<Value>,
 	S: BuildHasher + Default,
 {
-	default fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
+	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
 		self_.into_map().and_then(|map| {
 			map.into_iter()
 				.map(|(k, v)| Ok((k.downcast()?, v.downcast()?)))
@@ -1828,13 +1803,6 @@ where
 		})
 	}
 }
-#[doc(hidden)]
-#[allow(clippy::implicit_hasher)]
-impl DowncastFrom<Value> for HashMap<Value, Value> {
-	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
-		self_.into_map()
-	}
-}
 impl DowncastFrom<Value> for Group {
 	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
 		self_.into_group()
@@ -1844,19 +1812,13 @@ impl<T> DowncastFrom<Value> for Option<T>
 where
 	T: DowncastFrom<Value>,
 {
-	default fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
+	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
 		match self_.into_option()? {
 			Some(t) => t.downcast().map(Some),
 			None => Ok(None),
 		}
 	}
 }
-#[doc(hidden)]
-impl DowncastFrom<Value> for Option<Value> {
-	fn downcast_from(self_: Value) -> Result<Self, DowncastError> {
-		self_.into_option()
-	}
-}
 macro_rules! array_downcast {
 	($($i:tt)*) => {$(
 		impl<T: Data> DowncastFrom<Value> for [T; $i]
@@ -2334,9 +2296,9 @@ impl ListVec<Value> for ValueVec {
 	#[inline(always)]
 	fn into_vec(self) -> Vec<Value> {
 		match self {
-			Self::U8(vec) => vec.into_iter().map(Into::into).collect(),
-			Self::U16(vec) => vec.into_iter().map(Into::into).collect(),
-			Self::List(vec) => vec.into_iter().map(Into::into).collect(),
+			Self::U8(vec) => vec.map(Into::into),
+			Self::U16(vec) => vec.map(Into::into),
+			Self::List(vec) => vec.map(Into::into),
 			Self::Value(vec) => vec,
 		}
 	}
diff --git a/amadeus-types/src/value_required.rs b/amadeus-types/src/value_required.rs
index c6dd3f69..9f1a7474 100644
--- a/amadeus-types/src/value_required.rs
+++ b/amadeus-types/src/value_required.rs
@@ -83,115 +83,115 @@ impl Hash for ValueRequired {
 	fn hash<H: Hasher>(&self, state: &mut H) {
 		match self {
 			Self::Bool(value) => {
-				0u8.hash(state);
+				0_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U8(value) => {
-				1u8.hash(state);
+				1_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I8(value) => {
-				2u8.hash(state);
+				2_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U16(value) => {
-				3u8.hash(state);
+				3_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I16(value) => {
-				4u8.hash(state);
+				4_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U32(value) => {
-				5u8.hash(state);
+				5_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I32(value) => {
-				6u8.hash(state);
+				6_u8.hash(state);
 				value.hash(state);
 			}
 			Self::U64(value) => {
-				7u8.hash(state);
+				7_u8.hash(state);
 				value.hash(state);
 			}
 			Self::I64(value) => {
-				8u8.hash(state);
+				8_u8.hash(state);
 				value.hash(state);
 			}
 			Self::F32(_value) => {
-				9u8.hash(state);
+				9_u8.hash(state);
 			}
 			Self::F64(_value) => {
-				10u8.hash(state);
+				10_u8.hash(state);
 			}
 			Self::Date(value) => {
-				11u8.hash(state);
+				11_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateWithoutTimezone(value) => {
-				11u8.hash(state);
+				11_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Time(value) => {
-				12u8.hash(state);
+				12_u8.hash(state);
 				value.hash(state);
 			}
 			Self::TimeWithoutTimezone(value) => {
-				12u8.hash(state);
+				12_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateTime(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::DateTimeWithoutTimezone(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Timezone(value) => {
-				13u8.hash(state);
+				13_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Decimal(_value) => {
-				14u8.hash(state);
+				14_u8.hash(state);
 			}
 			Self::Bson(value) => {
-				15u8.hash(state);
+				15_u8.hash(state);
 				value.hash(state);
 			}
 			Self::String(value) => {
-				16u8.hash(state);
+				16_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Json(value) => {
-				17u8.hash(state);
+				17_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Enum(value) => {
-				18u8.hash(state);
+				18_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Url(value) => {
-				19u8.hash(state);
+				19_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Webpage(value) => {
-				20u8.hash(state);
+				20_u8.hash(state);
 				value.hash(state);
 			}
 			Self::IpAddr(value) => {
-				21u8.hash(state);
+				21_u8.hash(state);
 				value.hash(state);
 			}
 			Self::List(value) => {
-				22u8.hash(state);
+				22_u8.hash(state);
 				value.hash(state);
 			}
 			Self::Map(_value) => {
-				23u8.hash(state);
+				23_u8.hash(state);
 			}
 			Self::Group(_value) => {
-				24u8.hash(state);
+				24_u8.hash(state);
 			}
 		}
 	}
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index e067a702..c163301d 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -20,7 +20,7 @@ jobs:
       endpoint: alecmocatta
       default:
         rust_toolchain: nightly
-        rust_lint_toolchain: nightly-2020-06-26
+        rust_lint_toolchain: nightly-2020-07-06
         rust_flags: ''
         rust_features_clippy: ';aws;commoncrawl;parquet;postgres;csv;json;constellation aws commoncrawl parquet postgres csv json'
         rust_features: 'constellation aws commoncrawl parquet postgres csv json'
@@ -37,14 +37,14 @@ jobs:
           rust_target_run: 'x86_64-unknown-linux-gnu'
         # linux1:
         #   imageName: 'ubuntu-latest'
-        #   rust_target_run: 'x86_64-unknown-linux-musl' # TODO: https://github.com/rust-lang/rust/issues/73451
+        #   rust_target_run: 'x86_64-unknown-linux-musl'
 
   - template: rust-n.yml@templates
     parameters:
       endpoint: alecmocatta
       default:
         rust_toolchain: nightly
-        rust_lint_toolchain: nightly-2020-06-26
+        rust_lint_toolchain: nightly-2020-07-06
         rust_flags: ''
         rust_features_clippy: ';aws;commoncrawl;parquet;postgres;csv;json;aws commoncrawl parquet postgres csv json'
         rust_features: 'aws commoncrawl parquet postgres csv json'
diff --git a/examples/cloudfront_logs.rs b/examples/cloudfront_logs.rs
index 40ec1a91..900f2f4c 100644
--- a/examples/cloudfront_logs.rs
+++ b/examples/cloudfront_logs.rs
@@ -11,7 +11,6 @@
 //! cargo run --example cloudfront_logs --release
 //! ```
 
-#![type_length_limit = "13470730"]
 use amadeus::prelude::*;
 
 #[allow(unreachable_code)]
@@ -28,28 +27,19 @@ async fn main() {
 	.await
 	.unwrap();
 
-	let (sample, (histogram, count)) = rows
+	let histogram = rows
 		.par_stream()
 		.map(Result::unwrap)
-		.fork(
+		.pipe(
 			pool,
-			Identity.sample_unstable(10),
-			(
-				Identity
-					.map(|row: &CloudfrontRow| (row.time.truncate_minutes(60), ()))
-					.group_by(
-						|| 0,
-						|count, fold| count + fold.map_left(|()| 1).into_inner(),
-					),
-				Identity.count(),
-			),
+			Identity
+				.map(|row: CloudfrontRow| (row.time.truncate_minutes(60), ()))
+				.group_by(Identity.count()),
 		)
 		.await;
 	let mut histogram = histogram.into_iter().collect::<Vec<_>>();
 	histogram.sort();
 
-	println!("{} log lines analysed.", count);
-	println!("sample: {:#?}", sample);
 	println!(
 		"histogram:\n    {}",
 		histogram
diff --git a/src/lib.rs b/src/lib.rs
index c2a1f7e7..2aa37381 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,11 +4,10 @@
 //! <a href="https://crates.io/crates/amadeus">📦&nbsp;&nbsp;Crates.io</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://github.com/constellation-rs/amadeus">📑&nbsp;&nbsp;GitHub</a>&nbsp;&nbsp;│&nbsp;&nbsp;<a href="https://constellation.zulipchat.com/#narrow/stream/213231-amadeus">💬&nbsp;&nbsp;Chat</a>
 //! </strong></p>
 
-#![doc(html_root_url = "https://docs.rs/amadeus/0.2.5")]
+#![doc(html_root_url = "https://docs.rs/amadeus/0.3.0")]
 #![doc(
 	html_logo_url = "https://raw.githubusercontent.com/constellation-rs/amadeus/master/logo.svg?sanitize=true"
 )]
-#![feature(specialization)]
 #![warn(
 	// missing_copy_implementations,
 	// missing_debug_implementations,
@@ -21,7 +20,6 @@
 	clippy::pedantic,
 )]
 #![allow(
-	incomplete_features,
 	clippy::module_name_repetitions,
 	clippy::similar_names,
 	clippy::if_not_else,
diff --git a/src/pool/thread.rs b/src/pool/thread.rs
index 535c4cc9..412b249d 100644
--- a/src/pool/thread.rs
+++ b/src/pool/thread.rs
@@ -1,8 +1,11 @@
-use futures::{future, FutureExt, TryFutureExt};
+use async_std::sync::{channel, RecvError, Sender};
+use futures::{FutureExt, TryFutureExt};
 use std::{
-	future::Future, io, panic::{RefUnwindSafe, UnwindSafe}, sync::Arc
+	any::Any, future::Future, io, panic::{AssertUnwindSafe, RefUnwindSafe, UnwindSafe}, pin::Pin, sync::Arc
+};
+use tokio::{
+	runtime::Handle, task::{JoinError, LocalSet}
 };
-use tokio::task::spawn;
 
 use super::util::{assert_sync_and_send, Panicked};
 
@@ -12,6 +15,7 @@ const DEFAULT_TASKS_PER_CORE: usize = 100;
 struct ThreadPoolInner {
 	logical_cores: usize,
 	tasks_per_core: usize,
+	pool: Pool,
 }
 
 #[derive(Debug)]
@@ -20,9 +24,11 @@ impl ThreadPool {
 	pub fn new(tasks_per_core: Option<usize>) -> io::Result<Self> {
 		let logical_cores = num_cpus::get();
 		let tasks_per_core = tasks_per_core.unwrap_or(DEFAULT_TASKS_PER_CORE);
+		let pool = Pool::new(logical_cores);
 		Ok(ThreadPool(Arc::new(ThreadPoolInner {
 			logical_cores,
 			tasks_per_core,
+			pool,
 		})))
 	}
 	pub fn threads(&self) -> usize {
@@ -34,9 +40,10 @@ impl ThreadPool {
 		Fut: Future<Output = T> + 'static,
 		T: Send + 'static,
 	{
-		let _self = self;
-		spawn(DuckSend(future::lazy(|_| work()).flatten()))
-			.map_err(tokio::task::JoinError::into_panic)
+		self.0
+			.pool
+			.spawn_pinned(|| work())
+			.map_err(JoinError::into_panic)
 			.map_err(Panicked::from)
 	}
 }
@@ -58,42 +65,91 @@ fn _assert() {
 	let _ = assert_sync_and_send::<ThreadPool>;
 }
 
-// TODO remove when spawn_pinned exists https://github.com/tokio-rs/tokio/issues/2545
+#[derive(Debug)]
+struct Pool {
+	sender: Sender<(Request, Sender<Response>)>,
+}
 
-use pin_project::pin_project;
-use std::{
-	pin::Pin, task::{Context, Poll}
-};
-#[pin_project]
-struct DuckSend<F>(#[pin] F);
-impl<F> Future for DuckSend<F>
-where
-	F: Future,
-{
-	type Output = F::Output;
+type Request = Box<dyn FnOnce() -> Box<dyn Future<Output = Response>> + Send>;
+type Response = Result<Box<dyn Any + Send>, Box<dyn Any + Send + 'static>>;
 
-	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		// TODO!
-		// assert!(<F as IsSend>::is_send(), "{}", std::any::type_name::<F>());
-		self.project().0.poll(cx)
+impl Pool {
+	fn new(threads: usize) -> Self {
+		let handle = Handle::current();
+		let handle1 = handle.clone();
+		let (sender, receiver) = channel::<(Request, Sender<Response>)>(1);
+		for _ in 0..threads {
+			let receiver = receiver.clone();
+			let handle = handle.clone();
+			let _ = handle1.spawn_blocking(move || {
+				let local = LocalSet::new();
+				handle.block_on(local.run_until(async {
+					while let Ok((task, sender)) = receiver.recv().await {
+						let _ = local.spawn_local(async move {
+							let res = Pin::from(task()).await;
+							sender.send(res).await;
+						});
+					}
+				}))
+			});
+		}
+		Self { sender }
 	}
-}
-#[allow(unsafe_code)]
-unsafe impl<F> Send for DuckSend<F> {}
-
-trait IsSend {
-	fn is_send() -> bool;
-}
-impl<T: ?Sized> IsSend for T {
-	default fn is_send() -> bool {
-		false
+	fn spawn_pinned<F, Fut, T>(&self, task: F) -> impl Future<Output = Result<T, JoinError>> + Send
+	where
+		F: FnOnce() -> Fut + Send + 'static,
+		Fut: Future<Output = T> + 'static,
+		T: Send + 'static,
+	{
+		let sender = self.sender.clone();
+		async move {
+			let task: Request = Box::new(|| {
+				Box::new(
+					AssertUnwindSafe(task().map(|t| Box::new(t) as Box<dyn Any + Send>))
+						.catch_unwind(),
+				)
+			});
+			let (sender_, receiver) = channel::<Response>(1);
+			sender.send((task, sender_)).await;
+			let res = receiver.recv().await;
+			#[allow(deprecated)]
+			res.map_err(|RecvError| unreachable!()).and_then(|x| {
+				x.map(|x| *Box::<dyn Any + Send>::downcast(x).unwrap())
+					.map_err(JoinError::panic)
+			})
+		}
 	}
 }
-impl<T: ?Sized> IsSend for T
-where
-	T: Send,
-{
-	fn is_send() -> bool {
-		true
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use futures::future::join_all;
+	use std::sync::{
+		atomic::{AtomicUsize, Ordering}, Arc
+	};
+
+	#[tokio::test]
+	async fn spawn_pinned_() {
+		const TASKS: usize = 1000;
+		const ITERS: usize = 1000;
+		const THREADS: usize = 4;
+		let pool = Pool::new(THREADS);
+		let count = Arc::new(AtomicUsize::new((1..TASKS).sum()));
+		for _ in 0..ITERS {
+			join_all((0..TASKS).map(|i| {
+				let count = count.clone();
+				pool.spawn_pinned(move || async move {
+					let _ = count.fetch_sub(i, Ordering::Relaxed);
+				})
+			}))
+			.await
+			.into_iter()
+			.collect::<Result<(), _>>()
+			.unwrap();
+			assert_eq!(count.load(Ordering::Relaxed), 0);
+			count.store((1..TASKS).sum(), Ordering::Relaxed);
+		}
 	}
 }
diff --git a/src/source.rs b/src/source.rs
index 5bf11ccd..c42e50ec 100644
--- a/src/source.rs
+++ b/src/source.rs
@@ -2,14 +2,14 @@
 
 use ::serde::{Deserialize, Serialize};
 use derive_new::new;
-use futures::pin_mut;
+use futures::Stream;
 use pin_project::pin_project;
 use std::{
 	error::Error, fmt::Debug, marker::PhantomData, pin::Pin, task::{Context, Poll}
 };
 
 use crate::{
-	par_sink::{DistributedSink, ParallelSink}, par_stream::{DistributedStream, ParallelStream, StreamTask, StreamTaskAsync}
+	par_sink::{DistributedSink, ParallelSink}, par_stream::{DistributedStream, ParallelStream, StreamTask}
 };
 
 #[cfg(feature = "aws")]
@@ -226,21 +226,18 @@ where
 		}
 	}
 }
-impl<I, T, E, U> StreamTaskAsync for IntoTask<I, U>
+impl<I, T, E, U> Stream for IntoTask<I, U>
 where
-	I: StreamTaskAsync<Item = Result<T, E>>,
+	I: Stream<Item = Result<T, E>>,
 	T: Into<U>,
 {
 	type Item = Result<U, E>;
 
-	fn poll_run(
-		self: Pin<&mut Self>, cx: &mut Context,
-		sink: Pin<&mut impl amadeus_core::sink::Sink<Item = Self::Item>>,
-	) -> Poll<()> {
-		let sink =
-			amadeus_core::sink::SinkMap::new(sink, |item: Result<_, _>| item.map(Into::into));
-		pin_mut!(sink);
-		self.project().task.poll_run(cx, sink)
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		self.project()
+			.task
+			.poll_next(cx)
+			.map(|t| t.map(|t| t.map(Into::into)))
 	}
 }
 impl<I, T, E, U> Iterator for IntoStream<I, U>
diff --git a/tests/cloudfront.rs b/tests/cloudfront.rs
index 0392a996..804d39bd 100644
--- a/tests/cloudfront.rs
+++ b/tests/cloudfront.rs
@@ -1,4 +1,3 @@
-#![type_length_limit = "13470730"]
 #![allow(clippy::suspicious_map)]
 
 use amadeus::prelude::*;
diff --git a/tests/cloudfront_dist.rs b/tests/cloudfront_dist.rs
index 81eeed3d..cfa9fc5b 100644
--- a/tests/cloudfront_dist.rs
+++ b/tests/cloudfront_dist.rs
@@ -1,5 +1,3 @@
-#![type_length_limit = "13470730"]
-
 use amadeus::dist::prelude::*;
 #[cfg(feature = "constellation")]
 use constellation::*;
diff --git a/tests/into_par_stream.rs b/tests/into_par_stream.rs
index 86aa59c1..d20dbbfb 100644
--- a/tests/into_par_stream.rs
+++ b/tests/into_par_stream.rs
@@ -15,7 +15,7 @@ async fn into_par_stream() {
 	assert_eq!(res, 6);
 
 	let slice = [
-		0usize, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
+		0_usize, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
 		79, 83, 89, 97,
 	];
 	for i in 0..slice.len() {
@@ -24,7 +24,7 @@ async fn into_par_stream() {
 			.into_par_stream()
 			.fold(
 				&pool,
-				|| 0usize,
+				|| 0_usize,
 				|a: usize, b: Either<usize, usize>| a + b.into_inner(),
 			)
 			.await;
diff --git a/tests/into_par_stream_dist.rs b/tests/into_par_stream_dist.rs
index 82640c87..383d60d6 100644
--- a/tests/into_par_stream_dist.rs
+++ b/tests/into_par_stream_dist.rs
@@ -15,7 +15,7 @@ async fn main() {
 	assert_eq!(res, 6);
 
 	let slice = [
-		0usize, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
+		0_usize, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
 		79, 83, 89, 97,
 	];
 	for i in 0..slice.len() {
@@ -24,7 +24,7 @@ async fn main() {
 			.into_dist_stream()
 			.fold(
 				&pool,
-				FnMut!(|| 0usize),
+				FnMut!(|| 0_usize),
 				FnMut!(|a: usize, b: Either<usize, usize>| a + b.into_inner()),
 			)
 			.await;
diff --git a/tests/parquet.rs b/tests/parquet.rs
index 50b39dc0..fe2528bf 100644
--- a/tests/parquet.rs
+++ b/tests/parquet.rs
@@ -1,4 +1,4 @@
-#![type_length_limit = "13225240"]
+#![type_length_limit = "1207654"]
 #![allow(
 	clippy::cognitive_complexity,
 	clippy::type_complexity,
diff --git a/tests/parquet_dist.rs b/tests/parquet_dist.rs
index 0f0d66cb..8629e01d 100644
--- a/tests/parquet_dist.rs
+++ b/tests/parquet_dist.rs
@@ -1,4 +1,4 @@
-#![type_length_limit = "13225240"]
+#![type_length_limit = "1207654"]
 #![allow(clippy::cognitive_complexity, clippy::type_complexity)]
 
 #[cfg(feature = "constellation")]