Well, I guess I was wrong about this. I was confused by the place where the Haskell Report says: Unlike algebraic datatypes, the newtype constructor N is unlifted, so that N _|_ is the same as _|_. What I didn't realize was that matching against N is irrefutable. What I still don't understand is _why_ it is irrefutable. How (if at all) does this make them more efficient? In particular, it seems it would be possible to simulate the newtype with a datatype: The report says that if data D2=D2 !Int newtype N = N Int d2 (D2 i) = 42 n (N i) = 42 then d2 _|_ = _|_ d2 (D2 _|_) = _|_ n _|_ = 42 n (N_|_) = 42 If d2 were rewritten d2' ~(D2 i) = 42 then it would act just like n. I guess the question is whether the code for d2' is as efficient as the code for n. I don't see why it wouldn't be, but of course I could be wrong.