package sbt
package appmacro

import Types.Id
import scala.reflect._
import macros._

 * A `TupleBuilder` abstracts the work of constructing a tuple data structure such as a `TupleN` or `KList`
 * and extracting values from it.  The `Instance` macro implementation will (roughly) traverse the tree of its argument
 * and ultimately obtain a list of expressions with type `M[T]` for different types `T`.
 * The macro constructs an `Input` value for each of these expressions that contains the `Type` for `T`,
 * the `Tree` for the expression, and a `ValDef` that will hold the value for the input.
 * `TupleBuilder.apply` is provided with the list of `Input`s and is expected to provide three values in the returned BuilderResult.
 * First, it returns the constructed tuple data structure Tree in `input`.
 * Next, it provides the type constructor `representationC` that, when applied to M, gives the type of tuple data structure.
 * For example, a builder that constructs a `Tuple3` for inputs `M[Int]`, `M[Boolean]`, and `M[String]`
 * would provide a Type representing `[L[x]] (L[Int], L[Boolean], L[String])`.  The `input` method
 * would return a value whose type is that type constructor applied to M, or `(M[Int], M[Boolean], M[String])`.
 * Finally, the `extract` method provides a list of vals that extract information from the applied input.
 * The type of the applied input is the type constructor applied to `Id` (`[X] X`).
 * The returned list of ValDefs should be the ValDefs from `inputs`, but with non-empty right-hand sides.
trait TupleBuilder {
  /** A convenience alias for a list of inputs (associated with a Universe of type U). */
  type Inputs[U <: Universe with Singleton] = List[Instance.Input[U]]

  /** Constructs a one-time use Builder for Context `c` and type constructor `tcType`. */
  def make(c: Context)(tcType: c.Type, inputs: Inputs[c.universe.type]): BuilderResult[c.type]

trait BuilderResult[C <: Context with Singleton] {
  val ctx: C
  import ctx.universe._

   * Represents the higher-order type constructor `[L[x]] ...` where `...` is the
   * type of the data structure containing the added expressions,
   * except that it is abstracted over the type constructor applied to each heterogeneous part of the type .
  def representationC: PolyType

  /** The instance of AList for the input.  For a `representationC` of `[L[x]]`, this `Tree` should have a `Type` of `AList[L]`*/
  def alistInstance: Tree

  /** Returns the completed value containing all expressions added to the builder. */
  def input: Tree

  /* The list of definitions that extract values from a value of type `$representationC[Id]`.
	* The returned value should be identical to the `ValDef`s provided to the `TupleBuilder.make` method but with
	* non-empty right hand sides. Each `ValDef` may refer to `param` and previous `ValDef`s in the list.*/
  def extract(param: ValDef): List[ValDef]