#![warn(unsafe_code)]
#![warn(missing_copy_implementations)]
#![warn(missing_debug_implementations)]
#![feature(generators, generator_trait)]
#![feature(specialization)]
#![feature(type_ascription)]
#![feature(overlapping_marker_traits)]
pub mod generator;
pub mod shared;
pub mod singleton;
pub mod cartesian;
pub use enso_shapely_macros::*;
pub use generator::EmptyIterator;
pub use generator::GeneratingIterator;
use shrinkwraprs::Shrinkwrap;
#[macro_export]
macro_rules! replace {
($a:tt,$($b:tt)*) => {$($b)*}
}
#[macro_export]
macro_rules! newtype_prim_no_derives {
($( $(#$meta:tt)* $name:ident($type:ty); )*) => {$(
$(#$meta)*
pub struct $name {
raw:$type
}
impl $name {
/// Constructor.
pub const fn new(raw:$type) -> Self {
Self {raw}
}
}
impl Deref for $name {
type Target = $type;
fn deref(&self) -> &Self::Target {
&self.raw
}
}
impl DerefMut for $name {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.raw
}
}
impl From<$type> for $name { fn from(t:$type) -> Self { Self::new(t) } }
impl From<&$type> for $name { fn from(t:&$type) -> Self { Self::new(*t) } }
impl From<&&$type> for $name { fn from(t:&&$type) -> Self { Self::new(**t) } }
impl From<$name> for $type { fn from(t:$name) -> Self { t.raw } }
impl From<&$name> for $type { fn from(t:&$name) -> Self { t.raw } }
impl From<&&$name> for $type { fn from(t:&&$name) -> Self { t.raw } }
)*}
}
#[macro_export]
macro_rules! newtype_prim {
($( $(#$meta:tt)* $name:ident($type:ty); )*) => {
$crate::newtype_prim_no_derives! {
$(
$(#$meta)*
#[derive(Copy,Clone,CloneRef,Debug,Default,Display,Eq,Hash,Ord,PartialOrd,PartialEq)]
$name($type);
)*
}
}
}
#[macro_export]
macro_rules! newtype_prim_no_default {
($( $(#$meta:tt)* $name:ident($type:ty); )*) => {
$crate::newtype_prim_no_derives! {
$(
$(#$meta)*
#[derive(Copy,Clone,CloneRef,Debug,Display,Eq,Hash,Ord,PartialOrd,PartialEq)]
$name($type);
)*
}
}
}
#[macro_export]
macro_rules! newtype_prim_no_default_no_display {
($( $(#$meta:tt)* $name:ident($type:ty); )*) => {
$crate::newtype_prim_no_derives! {
$(
$(#$meta)*
#[derive(Copy,Clone,CloneRef,Debug,Eq,Hash,Ord,PartialOrd,PartialEq)]
$name($type);
)*
}
}
}
#[macro_export]
macro_rules! derive_clone_plus {
($name:ident) => {
impl<T:Clone+Into<$name>> From<&T> for $name {
fn from(t: &T) -> Self {
t.clone().into()
}
}
}
}
use std::ops::Deref;
macro_rules! extension_struct {
($name:ident { $($field:ident : $field_type:ty),* }) => { paste::item! {
#[derive(Shrinkwrap)]
#[shrinkwrap(mutable)]
struct [<With $name>]<T>($($field_type),*, #[shrinkwrap(main_field)] T);
pub trait [<Has $name>] {
$(fn $field(&self) -> &$field_type;)*
}
impl<T: [<Has $name Indirect>]>
[<Has $name>] for T {
$(fn $field(&self) -> &$field_type {
[<Has $name Spec1>]::$field(self)
})*
}
pub trait [<Has $name Indirect>] {}
impl<T>
[<Has $name Indirect>] for [<With $name>]<T> {}
impl<T>
[<Has $name Indirect>] for T
where T: Deref, <Self as Deref>::Target : [<Has $name>] {}
trait [<Has $name Spec1>] {
$(fn $field(&self) -> &$field_type;)*
}
impl<T>
[<Has $name Spec1>] for [<With $name>]<T> {
$(fn $field(&self) -> &$field_type {
&self.0
})*
}
impl<T: [<Has $name Indirect>]>
[<Has $name Spec1>] for T {
$(default fn $field(&self) -> &$field_type {
[<Has $name Spec2>]::$field(self)
})*
}
trait [<Has $name Spec2>] {
$(fn $field(&self) -> &$field_type;)*
}
impl<T: [<Has $name Indirect>]>
[<Has $name Spec2>] for T {
$(default fn $field(&self) -> &$field_type {
unreachable!();
})*
}
impl<T>
[<Has $name Spec2>] for T
where T: Deref, <Self as Deref>::Target : [<Has $name>] {
$(fn $field(&self) -> &$field_type {
self.deref().$field()
})*
}
}};
}
extension_struct!(Label {
label: String
});
extension_struct!(Foo {
t1: String
});
struct WithID<T>(i32, T);
impl<T> Deref for WithID<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.1
}
}
struct WithID2<T>(i32, T);
impl<T> Deref for WithID2<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.1
}
}
pub trait HasID {
fn id(&self) -> &i32;
}
#[overlappable]
impl<T> HasID for T
where T: Deref, <Self as Deref>::Target : HasID {
fn id(&self) -> &i32 {
self.deref().id()
}
}
impl<T: MarkerCtx_HasID> HasID for T {
fn id(&self) -> &i32 {
VariantOrAny_HasID::id(self)
}
}
#[allow(non_camel_case_types)]
pub trait MarkerCtx_HasID {}
impl<T> MarkerCtx_HasID for T
where T: Deref, <T as Deref>::Target : HasID {}
#[allow(non_camel_case_types)]
trait VariantOrAny_HasID {
fn id(&self) -> &i32;
}
impl<T: MarkerCtx_HasID> VariantOrAny_HasID for T {
default fn id(&self) -> &i32 {
DerefOrAny_HasID::id(self)
}
}
#[allow(non_camel_case_types)]
trait DerefOrAny_HasID {
fn id(&self) -> &i32;
}
impl<T> DerefOrAny_HasID for T
where T: Deref, <Self as Deref>::Target : HasID {
fn id(&self) -> &i32 {
self.deref().id()
}
}
impl<T> DerefOrAny_HasID for T {
default fn id(&self) -> &i32 {
unreachable!();
}
}
impl<T> MarkerCtx_HasID for WithID<T> {}
impl<T> VariantOrAny_HasID for WithID<T> {
fn id(&self) -> &i32 {
&self.0
}
}
struct _A(i32);
type _X = WithLabel<WithID<_A>>;
fn _test<T: HasID + HasLabel> (t: T) {
println!("{:?}", t.label());
println!("{:?}", t.id());
}
fn _main() {
let v1 = WithLabel("label1".to_string(), WithID(0, _A(1)));
_test(v1);
}