ExpressionDag

abstract def idToExp: HMap[Id, [β$0$]Expr[N, β$0$]]

These have package visibility to test the law that for all Expr, the node they evaluate to is unique

abstract def nextId: Int

abstract def nodeToLiteral: FunctionK[N, [β$1$]Literal[N, β$1$]]

abstract def roots: Set[Id[_]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addRoot[T](node: N[T]): (ExpressionDag[N], Id[T])

Add a GC root, or tail in the DAG, that can never be deleted.

def apply(rule: Rule[N]): ExpressionDag[N]

Apply the given rule to the given dag until the graph no longer changes.

def applyOnce(rule: Rule[N]): ExpressionDag[N]

apply the rule at the first place that satisfies it, and return from there.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(node: N[_]): Boolean

def dependentsOf(node: N[_]): Set[N[_]]

list all the nodes that depend on the given node

def ensure[T](node: N[T]): (ExpressionDag[N], Id[T])

ensure the given literal node is present in the Dag Note: it is important that at each moment, each node has at most one id in the graph.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluate[T](id: Id[T]): N[T]

After applying rules to your Dag, use this method to get the original node type.

def evaluateOption[T](id: Id[T]): Option[N[T]]

def fanOut(node: N[_]): Int

Returns 0 if the node is absent, which is true use .contains(n) to check for containment

def fanOut(id: Id[_]): Int

Return the number of nodes that depend on the given Id, TODO we might want to cache these.

def finalize(): Unit

def find[T](node: N[T]): Option[Id[T]]

This finds the Id[T] in the current graph that is equivalent to the given N[T]

final def getClass(): Class[_]

def hashCode(): Int

def idOf[T](node: N[T]): Id[T]

This throws if the node is missing, use find if this is not a logic error in your programming.

final def isInstanceOf[T0]: Boolean

def isRoot(n: N[_]): Boolean

Is this node a root of this graph

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toLiteral[T](n: N[T]): Literal[N, T]

Convert a N[T] to a Literal[T, N]

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit