dylanede

// Need an endpoint to drive everything (provide top level criteria) - Nodes don't actually have the data going through them - only construct and modify callbacks

// Need an abstraction for a dynamically updating time serise - notification of points adding, updating and removing, refreshing - NOT a stream, kind of like a signal for multiple values in parallel

// Node - given criteria object, constructs a collection of output points, delegating where necessary
// criteria object may be modified at runtime - node should then modify the subscription
// Should be possible to have node sub-graph templates (maybe just functions) for generation based on changes in data source sets
// Internally to the graph, criteria may be dynamically updated at run time (e.g. to implement "join-on")

// Criteria:

dylanede

use std::cell::RefCell;
use std::collections::HashMap;
use std::hash::{ Hash, SipHasher, Hasher };

thread_local!(static SYMBOL_HASHES: RefCell<HashMap<(*const u8, usize), u64>> = RefCell::new(HashMap::new()));

struct StaticSymbol {
    string: &'static str,
    hash: u64,
}

dylanede

trait Merge<A, B> {
    type Out;
    fn merge(a: A, b: B) -> Self::Out;
}
type MergeOut<A, B> = <() as Merge<A, B>>::Out;
fn merge<A, B>(a: A, b: B) -> MergeOut<A, B> where (): Merge<A, B> {
    <() as Merge<A, B>>::merge(a, b)
}
struct Unknown;
macro_rules! derive_merge_unknown {

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 }
}

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

#![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

#![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;

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

struct Zero;
struct One;

trait UInt {