--- a/aRDF/src/main/scala/Model.scala	Sun Jan 08 17:56:57 2012 -0500
+++ b/aRDF/src/main/scala/Model.scala	Sun Jan 08 19:05:57 2012 -0500
@@ -27,7 +27,7 @@
   val IRI : Isomorphic1[String, IRI]
 
   trait GraphObject {
-    def empty:Graph
+    def empty: Graph
     def apply(elems:Triple*):Graph
     def apply(it:Iterable[Triple]):Graph
   }

--- a/aRDF/src/main/scala/Test.scala	Sun Jan 08 17:56:57 2012 -0500
+++ b/aRDF/src/main/scala/Test.scala	Sun Jan 08 19:05:57 2012 -0500
@@ -40,6 +40,20 @@
     val tests = Seq(scalaTest, jenaTest)
     tests.foreach { _.test() }
     
+    import com.hp.hpl.jena._
+    import com.hp.hpl.jena.rdf.model._
+    import com.hp.hpl.jena.graph._
+    
+    val model = ModelFactory.createDefaultModel()
+//    model.read("http://www.w3.org/People/Berners-Lee/card")
+    model.getReader("TURTLE").read(model, "file:///tmp/card")
+    
+    val jenaGraph = new JenaModel.Graph(model.getGraph)
+    
+    val scalaGraph: ScalaModel#Graph = JenaToScala.transform(jenaGraph)
+    
+    println(scalaGraph)
+    
   }
   
 }
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/aRDF/src/main/scala/Transformer.scala	Sun Jan 08 19:05:57 2012 -0500
@@ -0,0 +1,65 @@
+package org.w3.rdf
+
+
+
+
+
+
+class Transformer[ModelA <: Model, ModelB <: Model](val a: ModelA, val b: ModelB) {
+  
+  def transform(graph: ModelA#Graph): b.Graph =
+    b.Graph(graph map (transformTriple _))
+    
+  def transformTriple(t: ModelA#Triple): b.Triple = {
+    val a.Triple(s, p, o) = t
+    b.Triple(transformSubject(s), transformPredicate(p), transformObject(o))
+  }
+  
+  def transformIRI(iri: ModelA#IRI): b.IRI = {
+    val a.IRI(i) = iri
+    b.IRI(i)
+  }
+  
+  def transformBNode(bn: a.BNode): b.BNode = {
+    val a.BNode(label) = bn
+    b.BNode(label)
+  }
+  
+  def transformNode(n: a.Node): b.Node = {
+    n match {
+      case a.NodeIRI(iri) => b.NodeIRI(transformIRI(iri))
+      case a.NodeBNode(label) => b.NodeBNode(transformBNode(label))
+    }
+  }
+    
+  def transformSubject(s: a.Subject): b.Subject = {
+    val a.SubjectNode(node) = s
+    b.SubjectNode(transformNode(node))
+  }
+  
+  def transformPredicate(p: a.Predicate): b.Predicate = {
+    val a.PredicateIRI(iri) = p
+    b.PredicateIRI(transformIRI(iri))
+  }
+
+  def transformObject(o: a.Object): b.Object = {
+    o match {
+      case a.ObjectNode(node) => b.ObjectNode(transformNode(node))
+      case a.ObjectLiteral(lit) => b.ObjectLiteral(transformLiteral(lit))
+    }
+  }
+  
+  def transformLiteral(literal: a.Literal): b.Literal = {
+    import a._
+    val a.Literal(lit: String, langtagOption: Option[LangTag], datatypeOption: Option[IRI]) = literal
+    b.Literal(
+      lit,
+      langtagOption map { case a.LangTag(lang) => b.LangTag(lang)},
+      datatypeOption map transformIRI)
+  }
+  
+}
+
+import org.w3.rdf.jena._
+
+object JenaToScala extends Transformer[JenaModel, ScalaModel](JenaModel, ScalaModel)