Dag

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 roots: Set[Id[_]]

The set of roots that were added by addRoot.

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

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

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

lazy val allNodes: Set[N[_]]

Find all the nodes currently in the graph

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

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

def applyMax(rule: Rule[N], cnt: Int): Dag[N]

Apply a rule at most cnt times.

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

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

def applySeq(phases: Seq[Rule[N]]): Dag[N]

Apply a sequence of rules, which you may think of as phases, in order First apply one rule until it does not apply, then the next, etc..

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Is this node in this DAG

def dependenciesOf(node: N[_]): List[N[_]]

What nodes do we depend directly on

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

list all the nodes that depend on the given node

def depthOf[A](n: N[A]): Option[Int]

def depthOfId[A](i: Id[A]): Option[Int]

def ensure[T](node: N[T]): (Dag[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.

def ensureFast[T](lit: Literal[N, T], memo: FunctionK[[β$9$]Literal[N, β$9$], N]): (Dag[N], Id[T])

def ensureRec[T](lit: Literal[N, T], memo: FunctionK[[β$10$]Literal[N, β$10$], N]): TailRec[(Dag[N], Id[T])]

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 an Id[T] in the current graph that is equivalent to the given N[T]

def findAll[T](node: N[T]): LazyList[Id[T]]

Nodes can have multiple ids in the graph, this gives all of them

final def getClass(): Class[_]

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

equivalent to (but maybe faster than) fanOut(n) <= 1

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

def reachableIds: Set[Id[_]]

Which ids are reachable from the roots?

def replaceId[A](newId: Id[A], expr: Expr[N, A], node: N[A]): Dag[N]

def repointIds[A](orig: N[A], oldIds: Iterable[Id[A]], newId: Id[A], newNode: N[A]): Dag[N]

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

def toString(): String

String representation of this DAG.

def transitiveDependenciesOf(p: N[_]): Set[N[_]]

Return the transitive dependencies of a given node

def transitiveDependentsOf(p: N[_]): Set[N[_]]

Return all dependents of a given node.

final def wait(): Unit

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

final def wait(arg0: Long): Unit