         p2 (p/promise p1)]
     (t/is (identical? p1 p2))))
 
-(t/deftest syncrhonize-promises
+(t/deftest syncrhonize-two-promises
   (let [p1 (-> (p/all [(p/promise 1) (p/promise 2)])
                (p/then (fn [[x y]]
                          (t/is (= x 1))

                             (t/is (p/rejected? p1))
                             (done))))))

(t/deftest promise-as-functor
  (t/async done
    (let [rp (m/fmap inc (p/promise 2))]

                   (t/is (= v 3))
                   (done))))))

(t/deftest first-monad-law-left-identity
  (t/async done
    (let [p1 (m/pure p/promise-context 4)
          p2 (m/pure p/promise-context 4)
          vl  (m/>>= p2 #(m/pure p/promise-context %))]
      (p/then (p/all [p1 vl])
              (fn [[v1 v2]]
                (t/is (= v1 v2))
                (done))))))

(t/deftest second-monad-law-right-identity
  (t/async done
    (let [p1 (p/promise 3)
          rs  (m/>>= (p/promise 3) m/return)]
      (p/then (p/all [p1 rs])
              (fn [[v1 v2]]
                (t/is (= v1 v2))
                (done))))))


(t/deftest third-monad-law-associativity
  (t/async done
    (let [rs1 (m/>>= (m/mlet [x (p/promise 2)
                              y (p/promise (inc x))]
                       (m/return y))
                     (fn [y] (p/promise (inc y))))
          rs2 (m/>>= (p/promise 2)
                     (fn [x] (m/>>= (p/promise (inc x))
                                    (fn [y] (p/promise (inc y))))))]
      (p/then (p/all [rs1 rs2])
              (fn [[v1 v2]]
                (t/is (= v1 v2))
                (done))))))

(t/deftest promisify
  (t/async done
    (let [func1 (fn [x cb] (cb (inc x)))
