                              (parent-func
                               uri bind meta
                               (map (fn [val] (child-func
-                                             uri (:uri val) bind meta (:html val))) vals))))]
+                                             uri (:uri val) bind meta (:html val))) vals))))
+                    vals (map (fn [val] {:uri (first val) :html (second val)})
+                           (map vector
+                                (map #(.toString %) related) ;; TODO this is a little sketchy
+                                (if (empty? sub-calls)
+                                  (map literalize related)
+                                  (map seq (apply map vector (map (fn [sub-call]
+                                                                    (map
+                                                                     (fn [val]
+                                                                       (sub-call data nil val url built-url))
+                                                                     related))
+                                                                  sub-calls))))))]
+
                 (func (.getURI resource) ;; apply the bound function to the thing, the binding that points at the funtion, meta-data, and the finished children (should be ordered by now).
                       (.getURI binding)
+                      meta-data
+                      vals))))
+          (= type :projector)
+
+          (let [statement (get-bound binding model) ;; fuckery for binding
+                relation-getter (fn [data resource] (relator statement data resource))
+                child-func (:value bindable)
+                parent-func (:resource bindable)
+                mypath (.getString (.asLiteral (first (relate-right model (prop (:path db)) binding))))
+                ]
+            (fn [data child resource url built-url]
+
+              (let [related (if child   ;; get sub-resources (a single one if partial rendering)
+                              (seq [child])
+                              (relation-getter data resource))
+                    func (if child ;; get the bound function
+                           (fn [uri bind active url meta vals]
+                             (let [val (first vals)]
+                               (child-func
+                                uri (:uri val) bind meta (:html val))))
+                           (fn [uri bind active url meta vals]
+                             (parent-func
+                              uri bind active url meta
+                              (map (fn [val] (child-func
+                                             uri (:uri val) bind meta (:html val))) vals))))
+                    current (get (parse-uri url) mypath)
+                    active (= current (.getURI resource))
+                    myurl (str built-url mypath "/" (.getURI resource) "/")]
+                (func (.getURI resource) ;; apply the bound function to the thing, the binding that points at the funtion, meta-data, and the finished children (should be ordered by now).
+                      (.getURI binding)
+                      active
+                      myurl
                       meta-data
                       (map (fn [val] {:uri (first val) :html (second val)})
                            (map vector


(defn uuid [] (str "urn:uuid:" (java.util.UUID/randomUUID)))

(def db (uris "http://logangilmour.com/data-binder#" :rank :root :binds :bindo  :haschild :projects))

(def funcs
  {:projector
   {:resource (fn [uri binding meta vals]
                (hic/html [:a {:href uri} vals]))
    :value identity
    :update nil
    :type :projector}
   :column8

                relation-getter (fn [data resource] (relator statement data resource))
                child-func (:value bindable)
                parent-func (:resource bindable)] ;; extraneous function getting]
            (fn [data child resource url built-url]

              (let [related (if child   ;; get sub-resources (a single one if partial rendering)
                              (seq [child])
