It's most of the way there, but not quite. For example, one frequently wants to do a hybrid approach to mutability where construction of the data structure is destructive, but then further manipulation is persistent. ST-backed arrays will get you part of the way there, but there's no easy way to efficiently unsafely freeze (the unsafe coercion from mutable to immutable) recursive mutable structures into persistent structures. You have to very carefully make sure the internal representations match up, and it's tricky enough that it's not done very often. I guess my real point is there is a cognitive cost for respecting the fine distinctions that Haskell makes you think about, which discourages certain styles of programming, but is good for the mind. :-)