dylanede

trait Apply {
    type Out;
}

trait Unapply {
    type Out;
}

type Applied<F, T> = <(F, T) as Apply>::Out;
type Unapplied<T> = <T as Unapply>::Out;

dylanede

//This trait is not used, but is useful for type equality constraints
trait ID {
    type Out;
}
impl<T> ID for T {
    type Out = T;
}

trait CanApply {
    type Out: CanUnapply;

dylanede

//This trait is not used, but is useful for type equality constraints
trait ID {
    type Out;
}
impl<T> ID for T {
    type Out = T;
}

trait CanApply {
    type Out: CanUnapply;

dylanede

#![feature(optin_builtin_traits)]
use std::marker::PhantomData;

struct Nil;
struct Cons<H, T>(H, T);

struct Zero;
struct One;

trait UInt {

dylanede

#![feature(optin_builtin_traits)]
use std::marker::PhantomData;

struct Nil;
struct Cons<H, T>(H, T);

struct Pair<A, B>(A, B);

trait Lookup_<S, Env> { type Type; }
type Lookup<S, Env> = <() as Lookup_<S, Env>>::Type;

dylanede

#![feature(optin_builtin_traits)]
use std::marker::PhantomData;

struct Nil;
struct Cons<H, T>(H, T);

struct Pair<A, B>(A, B);

trait Lookup_<S, Env> { type Type; }
type Lookup<S, Env> = <() as Lookup_<S, Env>>::Type;

dylanede

#![feature(optin_builtin_traits)]
use std::marker::PhantomData;

trait Lookup<K> {
    type V;
    fn get(&self) -> &Self::V;
}

struct Nil;

dylanede

#![feature(optin_builtin_traits)]
use std::marker::PhantomData;

trait Lookup<K> {
    type V;
    fn get(&self) -> &Self::V;
}

struct Nil;

dylanede

use std::collections::HashMap;
use std::marker::PhantomData;
use std::collections::hash_map;

pub trait DiffableIters<'a, T: Diffable> where T::Key: 'a, T::ListChild: 'a {
    type KeyIter: Iterator<Item=&'a T::Key>;
    type ListChildIter: Iterator<Item=&'a T::ListChild>;
}

pub type KeyIter<'a, T> = <T as DiffableIters<'a, T>>::KeyIter;

dylanede

use std::any::Any;
use std::rc::Rc;

trait AsAny {
    fn as_any(&self) -> &Any;
}

impl<T: Any> AsAny for T {
    fn as_any(&self) -> &Any { self }
}