Q:

Is it safe to postulate unit types are equal? 

Is it safe to postulate that all types of kind () are the same?  That is, can the following be used to break type safety? 
-- Bad postulate
unitsEqual :: (x :: ()) :~: (y :: ())
unitsEqual = unsafeCoerce (Refl :: '() :~: '())

A:

This is unsafe under GHC 7.8.3 (see code below).  As user2407038 remarks, the following is rejected by GHC 7.10.3.  Unsurprisingly, this data family is evil enough that the type checker was changed to prohibit it.  I'm still trying to see if there's a way to make this happen under 7.10.3. 
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE DataKinds #-}

module UnitsEqual where
import Unsafe. Coerce
import Data. Type. Equality

data family Yeah (a :: ()) b c
data instance Yeah '() b c = Yeah { yeah :: b }
data instance Yeah a b c = Nope c

-- Entirely valid
castYeah :: x :~: y -> Yeah x p q -> Yeah y p q
castYeah Refl x = x

-- Bad postulate
unitsEqual :: (x :: ()) :~: (y :: ())
unitsEqual = unsafeCoerce (Refl :: '() :~: '())

-- Oh no!  This doesn't actually cast, but
-- it's horrible enough.  It consistently produces
-- either segmentation faults or nonsense,
-- whether the types are the same or not. 
uc :: a -> b
uc a = yeah $ castYeah unitsEqual (Nope a)

I believe, however, that it is safe to postulate
voidsEqual :: (a :: Void) :~: (b :: Void)

because there's no apparent way to distinguish any of the stuck/bogus types inhabiting Void.