allow homogeneous inputs in addition to heterogeneous inputs (Node)

tasks/Execute.scala

@@ -5,7 +5,6 @@ package sbt
 
 // TODO: Incomplete needs to be parameterized with A[_] and have val node
 
-import Node._
 import Types._
 import Execute._
 
@@ -87,13 +86,21 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
 			readyInv( node )
 		}
 
-		state(node) = Calling
+		results.get(target) match {
-		addChecked(target)
+			case Some(result) => retire(node, result)
-		addCaller(node, target)
+			case None => 
+				state(node) = Calling
+				addChecked(target)
+				addCaller(node, target)
+		}
 
 		post {
-			assert( calling(node) )
+			if(done(target))
-			assert( callers(target) contains node )
+				assert(done(node))
+			else {
+				assert(calling(node) )
+				assert( callers(target) contains node )
+			}
 			readyInv( node )
 		}
 	}
@@ -200,8 +207,8 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
 	def submit[T]( node: A[T] )(implicit strategy: Strategy)
 	{
 		val v = view(node)
-		val rs: v.Inputs#Map[Result] = v.inputs.map(results)
+		val rs: v.Mixed#Map[Result] = v.mixedIn.map(results)
-		val ud = v.unitDependencies.flatMap(incomplete)
+		val ud = v.uniformIn.map(results.apply[v.Uniform])
 		strategy.submit( node, () => work(node, v.work(rs, ud)) )
 	}
 	/** Evaluates the computation 'f' for 'node'.
@@ -229,7 +236,7 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
 	def addCaller[T](caller: A[T], target: A[T]): Unit = callers.getOrUpdate(target, IDSet.create[A[T]]) += caller
 
 	def dependencies(node: A[_]): Iterable[A[_]] = dependencies(view(node))
-	def dependencies(v: Node[A, _]): Iterable[A[_]] = v.unitDependencies ++ v.inputs.toList
+	def dependencies(v: Node[A, _]): Iterable[A[_]] = v.uniformIn ++ v.mixedIn.toList
 
 		// Contracts
 

tasks/Node.scala

@@ -3,33 +3,16 @@
  */
 package sbt
 
-import Node._
 import Types._
 
 trait Node[A[_], T]
 {
-	type Inputs <: MList[A]
+	type Mixed <: MList[A]
-	type Results = Inputs#Map[Result]
+	type MixedResults = Mixed#Map[Result]
+	type Uniform
 
-	val inputs: Inputs
+	val mixedIn: Mixed
-	def unitDependencies: Iterable[A[_]]
+	val uniformIn: Seq[A[Uniform]]
 
-	def work(results: Results, units: UnitResults[A]): Either[A[T], T]
+	def work(mixed: MixedResults, uniform: Seq[Result[Uniform]]): Either[A[T], T]
-}
-
-object Node
-{
-	/*def pure[T](f: () => T): PureNode[T]= map[Id, T, MNil](MNil, Nil)((_,_) => f() )
-
-	def map[A[_], T, Inputs0 <: MList[A]](inputs0: Inputs0, deps0: Iterable[A[_]])(work0: (Inputs0#Map[Result], UnitResults[A]) => T):
-		Node[A,T] { type Inputs = Inputs0 } =
-			new Node[A,T] {
-				type Inputs = Inputs0
-				val inputs = inputs0
-				def unitDependencies = deps0
-				def work(results: Results, units: UnitResults[A]) = Right(work0(results, units))
-			}
-
-	type PureNode[T] = Node[Id, T] { type Inputs = MNil; type Results = MNil }*/
-	type UnitResults[A[_]] = Iterable[(A[_], Incomplete)]
 }