       "map-to-pair returns an RDD of (K, V) pairs formed by passing each element of the source
         RDD through a pair function"
       (-> (f/parallelize c ["a" "b" "c" "d"])
-          (f/map-to-pair (f/fn [x] [x 1]))
+          (f/map-to-pair (f/fn [x] (ft/tuple x 1)))
           (f/map f/untuple)
           f/collect
           vec) => [["a" 1] ["b" 1] ["c" 1] ["d" 1]])
 
      (fact
       "reduce-by-key returns an RDD of (K, V) when called on an RDD of (K, V) pairs"
-      (-> (f/parallelize c [["key1" 1]
-                            ["key1" 2]
-                            ["key2" 3]
-                            ["key2" 4]
-                            ["key3" 5]])
-          (f/map-to-pair identity)
+      (-> (f/parallelize-pairs c [(ft/tuple "key1" 1)
+                                  (ft/tuple "key1" 2)
+                                  (ft/tuple "key2" 3)
+                                  (ft/tuple "key2" 4)
+                                  (ft/tuple "key3" 5)])
           (f/reduce-by-key (f/fn [x y] (+ x y)))
           (f/map f/untuple)
           f/collect


     (fact
      "count-by-key returns a hashmap of (K, int) pairs with the count of each key; only available on RDDs of type (K, V)"
      (-> (f/parallelize c [["key1" 1]
                            ["key1" 2]
                            ["key2" 3]
                            ["key2" 4]
                            ["key3" 5]])
          (f/map-to-pair identity)
          (f/count-by-key)) => {"key1" 2 "key2" 2 "key3" 1})

     (fact


     (fact
      "left-outer-join returns an RDD of (K, (V, W)) when called on RDDs of type (K, V) and (K, W)"
      (let [LDATA (f/parallelize-pairs c [(ft/tuple "key1" [2])
                                          (ft/tuple "key2" [3])
                                          (ft/tuple "key3" [5])
                                          (ft/tuple "key4" [1])
                                          (ft/tuple "key5" [2])])
            RDATA (f/parallelize-pairs c [(ft/tuple "key1" [22])
                                          (ft/tuple "key3" [33])
                                          (ft/tuple "key4" [44])])]
        (-> (f/left-outer-join LDATA RDATA)
            ;; how to unwrap a left-outer-join
            (f/map (f/fn [t]
                     (let [[x t2] (f/untuple t)
