--- a/src/main/scala/SPARQL.scala	Sun Jan 31 20:30:34 2010 -0500
+++ b/src/main/scala/SPARQL.scala	Tue Feb 02 15:52:27 2010 -0500
@@ -30,42 +30,19 @@
 
 case class TriplePattern(s:S, p:P, o:O)
 
-sealed abstract class S
-case class SUri(u:Uri) extends S {
-  override def toString = "" + u
-}
-case class SVar(v:Var) extends S {
-  override def toString = "" + v
-}
+sealed trait S extends Term
+sealed trait O extends Term
+sealed trait P extends Term
 
-sealed abstract class O
-case class OUri(u:Uri) extends O {
-  override def toString = "" + u
-}
-case class OVar(v:Var) extends O {
-  override def toString = "" + v
-}
-case class OLit(lit:Literal) extends O {
+case class Literal(lit:RDFLiteral) extends O {
   override def toString = "" + lit
 }
 
-sealed abstract class P
-case class PUri(u:Uri) extends P {
-  override def toString = "" + u
-}
-case class PVar(v:Var) extends P {
-  override def toString = "" + v
-}
-
-case class Literal(lit:RDFLiteral) {
-  override def toString = "" + lit
-}
-
-case class Var(s:String) {
+case class Var(s:String) extends S with O {
   override def toString = "?" + s
 }
 
-case class Uri(s:String) {
+case class Uri(s:String) extends S with P with O {
   override def toString = "<" + s + ">"
 }
 
@@ -75,11 +52,7 @@
 case class PrimaryExpressionLt(left:SparqlTermExpression, right:SparqlTermExpression) extends PrimaryExpression
 case class SparqlTermExpression(term:Term)
 
-sealed abstract class Term
-case class TermUri(u:Uri) extends Term
-case class TermVar(v:Var) extends Term
-case class TermLit(lit:Literal) extends Term
-
+sealed trait Term
 
 case class Sparql() extends JavaTokenParsers {
 
@@ -110,9 +83,9 @@
   )
 
   def value:Parser[SparqlTermExpression] = (
-      qnameORuri ^^ { case x => SparqlTermExpression(TermUri(x)) }
-    | varr ^^ { x => SparqlTermExpression(TermVar(x)) }
-    | literal ^^ { x => SparqlTermExpression(TermLit(x)) }
+      qnameORuri ^^ { SparqlTermExpression(_) }
+    | varr ^^ { SparqlTermExpression(_) }
+    | literal ^^ { SparqlTermExpression(_) }
   )
 
   def attributelist:Parser[SparqlAttributeList] =
@@ -174,17 +147,17 @@
     subject ~ predicate ~ objectt ^^ { case s~p~o => TriplePattern(s, p, o) }
 
   def subject:Parser[S] = (
-      qnameORuri ^^ { case x => SUri(x) }
-    | varr ^^ { x => SVar(x) }
+      qnameORuri ^^ { case x => x }
+    | varr ^^ { case x => x }
   )
 
   def predicate:Parser[P] =
-    qnameORuri ^^ { x => PUri(x) }
+    qnameORuri
 
   def objectt:Parser[O] = (
-      qnameORuri ^^ { case x => OUri(x) }
-    | varr ^^ { x => OVar(x) }
-    | literal ^^ { x => OLit(x) }
+      qnameORuri
+    | varr
+    | literal
   )
 
   def qnameORuri:Parser[Uri] = (

--- a/src/main/scala/SparqlToSparql.scala	Sun Jan 31 20:30:34 2010 -0500
+++ b/src/main/scala/SparqlToSparql.scala	Tue Feb 02 15:52:27 2010 -0500
@@ -10,44 +10,26 @@
 import w3c.sw.sparql
 
 object SparqlToSparql {
-  def substituteTerm (changeMe:sparql.S, from:sparql.Term, to:sparql.Term):sparql.S = {
-    if (toTerm(changeMe) == from) to match {
-      case sparql.TermUri(u) => sparql.SUri(u)
-      case sparql.TermVar(v) => sparql.SVar(v)
-      case sparql.TermLit(l) => error("literal subject \"" + l + "\" not allowed in SPARQL")
-    }
+  def substituteTerm (changeMe:sparql.Term, from:sparql.Term, to:sparql.Term):sparql.Term = {
+    if (changeMe == from) to
     else changeMe
   }
-  def substituteTerm (changeMe:sparql.O, from:sparql.Term, to:sparql.Term):sparql.O = {
-    if (toTerm(changeMe) == from) to match {
-      case sparql.TermUri(u) => sparql.OUri(u)
-      case sparql.TermVar(v) => sparql.OVar(v)
-      case sparql.TermLit(l) => sparql.OLit(l)
-    }
-    else changeMe
-  }
-  def toTerm (term:sparql.S):sparql.Term = {
-    term match {
-      case sparql.SUri(u) => sparql.TermUri(u)
-      case sparql.SVar(v) => sparql.TermVar(v)
-    }
-  }
-  def toTerm (term:sparql.O):sparql.Term = {
-    term match {
-      case sparql.OUri(u) => sparql.TermUri(u)
-      case sparql.OVar(v) => sparql.TermVar(v)
-      case sparql.OLit(l) => sparql.TermLit(l)
-    }
-  }
+  // def termToS (term:sparql.Term):sparql.S = {
+  //   term match {
+  //     case u:sparql.Uri => u
+  //     case v:sparql.Var => v
+  //   }
+  // }
+
   def substitute (gp:sparql.GraphPattern, from:sparql.Term, to:sparql.Term) = {
     gp match {
       case sparql.TriplesBlock(triplepatterns) => sparql.TriplesBlock(
 	triplepatterns.map((tp) => {
 	  // println("sub(" + tp.o + ", " + from + ", " + to + ") => ")
 	  // println(substituteTerm(toTerm(tp.o), tp.o, from, to))
-	  sparql.TriplePattern(substituteTerm(tp.s, from, to),
+	  sparql.TriplePattern({if (tp.s == from) to.asInstanceOf[sparql.S] else tp.s},
 			       tp.p,
-			       substituteTerm(tp.o, from, to))
+			       {if (tp.o == from) to.asInstanceOf[sparql.O] else tp.o})
 	}
       ))
       case _ => error("not implemented" + gp)
@@ -56,13 +38,13 @@
   case class HornRule (head:sparql.TriplePattern, gp:sparql.GraphPattern) {
     override def toString = "{" + head + "} => {" + gp + "}"
     def transform (tp:sparql.TriplePattern):sparql.GraphPattern = {
-      substitute(substitute(gp, toTerm(head.s), toTerm(tp.s)), toTerm(head.o), toTerm(tp.o))
+      substitute(substitute(gp, head.s, tp.s), head.o, tp.o)
     }
   }
   case class RuleMap (rules:Map[sparql.Uri, HornRule]) {
     def transform (tp:sparql.TriplePattern):sparql.GraphPattern = {
       tp.p match {
-	case sparql.PUri(u) =>
+	case u:sparql.Uri =>
 	  try { rules(u).transform(tp) } catch {
 	    case e:java.util.NoSuchElementException => sparql.TriplesBlock(List(tp))
 	  }
@@ -89,7 +71,7 @@
       constructs.foldLeft(Map[sparql.Uri, HornRule]())((m, rule) => {
 	rule.head.triplepatterns.foldLeft(m)((m, tp) => m + ({
 	  tp.p match {
-	    case sparql.PUri(u) => u -> HornRule(tp, rule.gp)
+	    case u:sparql.Uri => u -> HornRule(tp, rule.gp)
 	    case _ => error("not implemented: " + tp.p)
 	  }
 	}))

--- a/src/main/scala/SparqlToSql.scala	Sun Jan 31 20:30:34 2010 -0500
+++ b/src/main/scala/SparqlToSql.scala	Tue Feb 02 15:52:27 2010 -0500
@@ -116,16 +116,16 @@
 */
   def relVarFromS(s:sparql.S):sql.RelVar = {
     s match {
-      case sparql.SUri(ob) => relVarFromNode(ob)
-      case sparql.SVar(v) => relVarFromVar(v)
+      case u:sparql.Uri => relVarFromNode(u)
+      case v:sparql.Var => relVarFromVar(v)
     }
   }
 
   def relVarFromO(o:sparql.O):sql.RelVar = {
     o match {
-      case sparql.OUri(ob) => relVarFromNode(ob)
-      case sparql.OVar(v) => relVarFromVar(v)
-      case sparql.OLit(l) => relVarFromLiteral(l)
+      case u:sparql.Uri => relVarFromNode(u)
+      case v:sparql.Var => relVarFromVar(v)
+      case l:sparql.Literal => relVarFromLiteral(l)
     }
   }
 
@@ -236,8 +236,8 @@
   def bindOnPredicate(db:sql.DatabaseDesc, stateP:R2RState, triple:sparql.TriplePattern, enforceForeignKeys:Boolean):R2RState = {
     val sparql.TriplePattern(s, p, o) = triple
     p match {
-      case sparql.PVar(v) => error("variable predicates require tedious enumeration; too tedious for me.")
-      case sparql.PUri(uri) => {
+//      case v:sparql.Var => error("variable predicate " +  +" require tedious enumeration; too tedious for me.")
+      case uri:sparql.Uri => {
 	val PUri(stem, spRel, spAttr) = parsePredicateURI(uri)
 	/* Attributes that come from the predicate: */
 	val rel = sql.Relation(sql.Name(spRel.s))
@@ -247,8 +247,8 @@
 	/* Attributes that come from the subject: */
 	val objattr = sql.RelVarAttr(relvar, attr)
 	val state_postSubj = s match {
-	  case sparql.SUri(u) => uriConstraint(stateP, sql.RelVarAttr(relvar, db.relationdescs(rel).primarykey.get), parseObjectURI(u), true)
-	  case sparql.SVar(v) => varConstraint(stateP, relvar, db.relationdescs(rel).primarykey, v, db, rel)
+	  case u:sparql.Uri => uriConstraint(stateP, sql.RelVarAttr(relvar, db.relationdescs(rel).primarykey.get), parseObjectURI(u), true)
+	  case v:sparql.Var => varConstraint(stateP, relvar, db.relationdescs(rel).primarykey, v, db, rel)
 	}
 	val state_subjJoin = R2RState(state_postSubj.joins + sql.InnerJoin(sql.AliasedResource(rel,relvar), None), state_postSubj.varmap, state_postSubj.exprs)
 
@@ -284,9 +284,9 @@
 	  case sql.Value(dt) => (objattr, rel, dt, state_subjJoin)
 	}
 	o match {
-	  case sparql.OLit(l) => literalConstraint(state_fkeys, targetattr, l, dt)
-	  case sparql.OUri(u) => uriConstraint    (state_fkeys, targetattr, parseObjectURI(u), enforceForeignKeys)
-	  case sparql.OVar(v) => varConstraint    (state_fkeys, targetattr.relvar, Some(targetattr.attribute), v, db, targetrel)
+	  case l:sparql.Literal => literalConstraint(state_fkeys, targetattr, l, dt)
+	  case u:sparql.Uri => uriConstraint    (state_fkeys, targetattr, parseObjectURI(u), enforceForeignKeys)
+	  case v:sparql.Var => varConstraint    (state_fkeys, targetattr.relvar, Some(targetattr.attribute), v, db, targetrel)
 	}
       }
     }
@@ -295,11 +295,11 @@
   def findVars(triple:sparql.TriplePattern):Set[sparql.Var] = {
     val sparql.TriplePattern(s, p, o) = triple
     val varS:Set[sparql.Var] = s match {
-      case sparql.SVar(v) => Set(v)
+      case v:sparql.Var => Set(v)
       case _              => Set()
     }
     val varO:Set[sparql.Var] = o match {
-      case sparql.OVar(v) => Set(v)
+      case v:sparql.Var => Set(v)
       case _              => Set()
     }
     varS ++ varO
@@ -401,21 +401,21 @@
 // sql.RelationalExpressionEq(_,_) === (x,y) => PrymaryExpressionEq(x,y)
     lTerm match {
       // does not handle FILTER (<x> = ?v)
-      case sparql.TermUri(obj) => error("only SPARQL PrimaryExpressions with a variable on the left have been implemented: punting on " + f)
+      case f:sparql.Uri => error("only SPARQL PrimaryExpressions with a variable on the left have been implemented: punting on " + f)
       // FILTER (?v = <x> && ?v = ?x && ?v = 7)
-      case sparql.TermVar(v) => { // :sparql.Var
+      case v:sparql.Var => { // :sparql.Var
 	val l = varToAttribute(varmap, v)
 	val r = rTerm match {
-	  case sparql.TermUri(obj) => null // :sparql.Uri
-	  case sparql.TermVar(v) => { // :sparql.Var
+	  case u:sparql.Uri => error ("!") // !!! :sparql.Uri
+	  case v:sparql.Var => { // :sparql.Var
 	    sql.PrimaryExpressionAttr(varToAttribute(varmap, v))
 	  }
-	  case sparql.TermLit(lit) => null // :sparql.Literal => sql.PrimaryExpressionTyped(sql.Datatype, lit.n)
+	  case sparql.Literal(lit) => error ("!") // !!! :sparql.Literal => sql.PrimaryExpressionTyped(sql.Datatype, lit.n)
 	}
 	sqlexpr(sql.PrimaryExpressionAttr(l), r)
       }
       // does not handle FILTER (7 = ?v)
-      case sparql.TermLit(lit) => error("only SPARQL PrimaryExpressions with a variable on the left have been implemented: punting on " + f)
+      case sparql.Literal(lit) => error("only SPARQL PrimaryExpressions with a variable on the left have been implemented: punting on " + f)
     }
   }
 

--- a/src/test/scala/SparqlTest.scala	Sun Jan 31 20:30:34 2010 -0500
+++ b/src/test/scala/SparqlTest.scala	Tue Feb 02 15:52:27 2010 -0500
@@ -11,7 +11,7 @@
     val e = """
 ?emp      <http://hr.example/DB/Employee#lastName>   "bob"^^<http://www.w3.org/2001/XMLSchema#string>
 """
-    val expected = TriplesBlock(List(TriplePattern(SVar(Var("emp")),PUri(Uri("http://hr.example/DB/Employee#lastName")),OLit(Literal(RDFLiteral("bob",Datatype(new URI("http://www.w3.org/2001/XMLSchema#string"))))))))
+    val expected = TriplesBlock(List(TriplePattern(Var("emp"),Uri("http://hr.example/DB/Employee#lastName"),Literal(RDFLiteral("bob",Datatype(new URI("http://www.w3.org/2001/XMLSchema#string")))))))
     assert(expected === (a.parseAll(a.triplesblock, e).get))
   }
 
@@ -20,7 +20,7 @@
     val e = """
 ?emp      <http://hr.example/DB/Employee#age>   "21"^^<http://www.w3.org/2001/XMLSchema#integer>
 """
-    val expected = TriplesBlock(List(TriplePattern(SVar(Var("emp")),PUri(Uri("http://hr.example/DB/Employee#age")),OLit(Literal(RDFLiteral("21",Datatype(new URI("http://www.w3.org/2001/XMLSchema#integer"))))))))
+    val expected = TriplesBlock(List(TriplePattern(Var("emp"),Uri("http://hr.example/DB/Employee#age"),Literal(RDFLiteral("21",Datatype(new URI("http://www.w3.org/2001/XMLSchema#integer")))))))
     assert(expected === (a.parseAll(a.triplesblock, e).get))
   }
 
@@ -35,17 +35,17 @@
       TriplesBlock(
 	List(
 	  TriplePattern(
-	    SVar(Var("emp")),
-	    PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	    OVar(Var("empName"))),
+	    Var("emp"),
+	    Uri("http://hr.example/DB/Employee#lastName"),
+	    Var("empName")),
 	  TriplePattern(
-	    SVar(Var("emp")),
-	    PUri(Uri("http://hr.example/DB/Employee#manager")),
-	    OVar(Var("manager"))),
+	    Var("emp"),
+	    Uri("http://hr.example/DB/Employee#manager"),
+	    Var("manager")),
 	  TriplePattern(
-	    SVar(Var("manager")),
-	    PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	    OVar(Var("managName")))))
+	    Var("manager"),
+	    Uri("http://hr.example/DB/Employee#lastName"),
+	    Var("managName"))))
     assert(tps === a.parseAll(a.triplesblock, e).get)
   }
 
@@ -55,7 +55,7 @@
     val e = """
 ?emp
 """
-    val expected = SparqlTermExpression(TermVar(Var("emp")))
+    val expected = SparqlTermExpression(Var("emp"))
     assert(expected === (a.parseAll(a.value, e).get))
   }
 
@@ -64,7 +64,7 @@
     val e = """
 ?emp<?emp
 """
-    val expected = PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("emp"))), SparqlTermExpression(TermVar(Var("emp"))))
+    val expected = PrimaryExpressionLt(SparqlTermExpression(Var("emp")), SparqlTermExpression(Var("emp")))
     assert(expected === (a.parseAll(a.primaryexpression, e).get))
   }
 
@@ -74,8 +74,8 @@
 ?manBday < ?empBday && ?grandManBday < ?manBday
 """
     val expected = Expression(List(
-      PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("manBday"))), SparqlTermExpression(TermVar(Var("empBday")))), 
-      PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("grandManBday"))), SparqlTermExpression(TermVar(Var("manBday"))))))
+      PrimaryExpressionLt(SparqlTermExpression(Var("manBday")), SparqlTermExpression(Var("empBday"))), 
+      PrimaryExpressionLt(SparqlTermExpression(Var("grandManBday")), SparqlTermExpression(Var("manBday")))))
     assert(expected === (a.parseAll(a.expression, e).get))
   }
 
@@ -85,8 +85,8 @@
 FILTER(?manBday < ?empBday && ?grandManBday < ?manBday)
 """
     val expected = Expression(List(
-      PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("manBday"))), SparqlTermExpression(TermVar(Var("empBday")))), 
-      PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("grandManBday"))), SparqlTermExpression(TermVar(Var("manBday"))))))
+      PrimaryExpressionLt(SparqlTermExpression(Var("manBday")), SparqlTermExpression(Var("empBday"))), 
+      PrimaryExpressionLt(SparqlTermExpression(Var("grandManBday")), SparqlTermExpression(Var("manBday")))))
     assert(expected === (a.parseAll(a.filter, e).get))
   }
 
@@ -104,9 +104,9 @@
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("emp")),
-		PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	      OVar(Var("empName"))))))
+	      Var("emp"),
+		Uri("http://hr.example/DB/Employee#lastName"),
+	      Var("empName")))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -125,9 +125,9 @@
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("emp")),
-		PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	      OVar(Var("empName"))))))
+	      Var("emp"),
+		Uri("http://hr.example/DB/Employee#lastName"),
+	      Var("empName")))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -146,14 +146,14 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("emp")),
-		PUri(Uri("http://hr.example/DB/Employee#lastName")),
-		OVar(Var("empName"))))),
+		Var("emp"),
+		Uri("http://hr.example/DB/Employee#lastName"),
+		Var("empName")))),
 	  Expression(List(
-	    PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("manBday"))),
-				      SparqlTermExpression(TermVar(Var("empBday")))), 
-	    PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("grandManBday"))),
-				      SparqlTermExpression(TermVar(Var("manBday"))))))))
+	    PrimaryExpressionLt(SparqlTermExpression(Var("manBday")),
+				      SparqlTermExpression(Var("empBday"))), 
+	    PrimaryExpressionLt(SparqlTermExpression(Var("grandManBday")),
+				      SparqlTermExpression(Var("manBday")))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -172,17 +172,17 @@
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("emp")),
-		PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	      OVar(Var("empName"))),
+	      Var("emp"),
+		Uri("http://hr.example/DB/Employee#lastName"),
+	      Var("empName")),
 	    TriplePattern(
-	      SVar(Var("emp")),
-	      PUri(Uri("http://hr.example/DB/Employee#manager")),
-	      OVar(Var("manager"))),
+	      Var("emp"),
+	      Uri("http://hr.example/DB/Employee#manager"),
+	      Var("manager")),
 	    TriplePattern(
-	      SVar(Var("manager")),
-	      PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	      OVar(Var("managName"))))))
+	      Var("manager"),
+	      Uri("http://hr.example/DB/Employee#lastName"),
+	      Var("managName")))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -218,9 +218,9 @@
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("x")),
-	      PUri(Uri("http://hr.example/DB/Employee#manager")),
-	      OVar(Var("y"))))))
+	      Var("x"),
+	      Uri("http://hr.example/DB/Employee#manager"),
+	      Var("y")))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -236,15 +236,15 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))),
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))),
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))))))
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -260,15 +260,15 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))),
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))),
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))))))
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -284,16 +284,16 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))),
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))),
 	  OptionalGraphPattern(
 	    TriplesBlock(
 	      List(
 		TriplePattern(
-		  SVar(Var("x")),
-		  PUri(Uri("http://hr.example/DB/Employee#manager")),
-		  OVar(Var("y")))))))))
+		  Var("x"),
+		  Uri("http://hr.example/DB/Employee#manager"),
+		  Var("y"))))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -309,9 +309,9 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y")))))))
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y"))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -327,16 +327,16 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("x")),
-		PUri(Uri("http://hr.example/DB/Employee#manager")),
-		OVar(Var("y"))))),
+		Var("x"),
+		Uri("http://hr.example/DB/Employee#manager"),
+		Var("y")))),
 	  MinusGraphPattern(
 	    TriplesBlock(
 	      List(
 		TriplePattern(
-		  SVar(Var("x")),
-		  PUri(Uri("http://hr.example/DB/Employee#manager")),
-		  OVar(Var("y")))))))))
+		  Var("x"),
+		  Uri("http://hr.example/DB/Employee#manager"),
+		  Var("y"))))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -360,39 +360,39 @@
 	  TriplesBlock(
 	    List(
 	      TriplePattern(
-		SVar(Var("who")),
-		PUri(Uri("http://hr.example/DB/Employee#lastName")),
-		OLit(Literal(RDFLiteral("Smith",Datatype(new URI("http://www.w3.org/2001/XMLSchema#string")))))))),
+		Var("who"),
+		Uri("http://hr.example/DB/Employee#lastName"),
+		Literal(RDFLiteral("Smith",Datatype(new URI("http://www.w3.org/2001/XMLSchema#string"))))))),
 	  TableDisjunction(List(
 	    TriplesBlock(
 	      List(
 		TriplePattern(
-		  SVar(Var("above")),
-		  PUri(Uri("http://hr.example/DB/Manage#manages")),
-		  OVar(Var("who"))),
+		  Var("above"),
+		  Uri("http://hr.example/DB/Manage#manages"),
+		  Var("who")),
 		TriplePattern(
-		  SVar(Var("above")),
-		  PUri(Uri("http://hr.example/DB/Manage#manager")),
-		  OVar(Var("manager"))),
+		  Var("above"),
+		  Uri("http://hr.example/DB/Manage#manager"),
+		  Var("manager")),
 		TriplePattern(
-		  SVar(Var("manager")),
-		  PUri(Uri("http://hr.example/DB/Employee#lastName")),
-		  OVar(Var("name")))
+		  Var("manager"),
+		  Uri("http://hr.example/DB/Employee#lastName"),
+		  Var("name"))
 	      )),
 	    TriplesBlock(
 	      List(
 		TriplePattern(
-		  SVar(Var("below")),
-		  PUri(Uri("http://hr.example/DB/Manage#manager")),
-		  OVar(Var("who"))),
+		  Var("below"),
+		  Uri("http://hr.example/DB/Manage#manager"),
+		  Var("who")),
 		TriplePattern(
-		  SVar(Var("below")),
-		  PUri(Uri("http://hr.example/DB/Manage#manages")),
-		  OVar(Var("managed"))),
+		  Var("below"),
+		  Uri("http://hr.example/DB/Manage#manages"),
+		  Var("managed")),
 		TriplePattern(
-		  SVar(Var("managed")),
-		  PUri(Uri("http://hr.example/DB/Employee#lastName")),
-		  OVar(Var("name")))
+		  Var("managed"),
+		  Uri("http://hr.example/DB/Employee#lastName"),
+		  Var("name"))
 	      )))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
@@ -412,12 +412,12 @@
 """
     val tps =
       Select(SparqlAttributeList(List(Var("emp1Name"), Var("emp2Name"), Var("emp3Name"))),
-       TableFilter(TableConjunction(List(TriplesBlock(List(TriplePattern(SVar(Var("emp1")), PUri(Uri("http://hr.example/DB/Employee#lastName")), OVar(Var("emp1Name"))))),
-					 OptionalGraphPattern(TriplesBlock(List(TriplePattern(SVar(Var("emp1")), PUri(Uri("http://hr.example/DB/Employee#birthday")), OVar(Var("birthday")))))),
-					 TriplesBlock(List(TriplePattern(SVar(Var("emp2")), PUri(Uri("http://hr.example/DB/Employee#lastName")), OVar(Var("emp2Name"))))),
-					 OptionalGraphPattern(TriplesBlock(List(TriplePattern(SVar(Var("emp2")), PUri(Uri("http://hr.example/DB/Employee#birthday")), OVar(Var("birthday")))))),
-					 TriplesBlock(List(TriplePattern(SVar(Var("emp4")),PUri(Uri("http://hr.example/DB/Employee#birthday")),OVar(Var("birthday"))))))),
-		   Expression(List(PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("emp1Name"))),SparqlTermExpression(TermVar(Var("emp2Name")))), PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("emp2Name"))),SparqlTermExpression(TermVar(Var("emp3Name")))), PrimaryExpressionLt(SparqlTermExpression(TermVar(Var("emp3Name"))),SparqlTermExpression(TermVar(Var("emp4Name"))))))))
+       TableFilter(TableConjunction(List(TriplesBlock(List(TriplePattern(Var("emp1"), Uri("http://hr.example/DB/Employee#lastName"), Var("emp1Name")))),
+					 OptionalGraphPattern(TriplesBlock(List(TriplePattern(Var("emp1"), Uri("http://hr.example/DB/Employee#birthday"), Var("birthday"))))),
+					 TriplesBlock(List(TriplePattern(Var("emp2"), Uri("http://hr.example/DB/Employee#lastName"), Var("emp2Name")))),
+					 OptionalGraphPattern(TriplesBlock(List(TriplePattern(Var("emp2"), Uri("http://hr.example/DB/Employee#birthday"), Var("birthday"))))),
+					 TriplesBlock(List(TriplePattern(Var("emp4"),Uri("http://hr.example/DB/Employee#birthday"),Var("birthday")))))),
+		   Expression(List(PrimaryExpressionLt(SparqlTermExpression(Var("emp1Name")),SparqlTermExpression(Var("emp2Name"))), PrimaryExpressionLt(SparqlTermExpression(Var("emp2Name")),SparqlTermExpression(Var("emp3Name"))), PrimaryExpressionLt(SparqlTermExpression(Var("emp3Name")),SparqlTermExpression(Var("emp4Name")))))))
     assert(tps === a.parseAll(a.select, e).get)
   }
 
@@ -434,15 +434,15 @@
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("emp")),
-	      PUri(Uri("http://xmlns.com/foaf/0.1/last_name")),
-	      OVar(Var("empName"))))),
+	      Var("emp"),
+	      Uri("http://xmlns.com/foaf/0.1/last_name"),
+	      Var("empName")))),
 	TriplesBlock(
 	  List(
 	    TriplePattern(
-	      SVar(Var("emp")),
-	      PUri(Uri("http://hr.example/DB/Employee#lastName")),
-	      OVar(Var("empName"))))))
+	      Var("emp"),
+	      Uri("http://hr.example/DB/Employee#lastName"),
+	      Var("empName")))))
     assert(tps === a.parseAll(a.construct, e).get)
   }